home *** CD-ROM | disk | FTP | other *** search
/ Gekkan Dennou Club 147 / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan).7z / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan) (Track 1).bin / fdimg / —‹Œêsrc.lzh / etc.c < prev    next >
C/C++ Source or Header  |  1993-03-19  |  50KB  |  2,977 lines
  1. #include    "3DDEF.H"
  2. #include    "GLOBAL.H"
  3. #include    "FORWARD.H"
  4. #include    "XCODE.H"
  5. #include    "doslib.h"
  6. #include    "prnt0.c"
  7.  
  8. void
  9. etc_rot_font(UINT c,FNTDATA *BUF)
  10. {
  11.     register STR dp;
  12.     register int x,y,x8,mask;
  13.     UBYTE w0[24*3];
  14.  
  15.     if ((BUF->xl == 24) && (BUF->yl == 24)) {
  16.         dp = BUF->buffer;
  17.         if (c <= L'ヶ') {
  18.             x = 0;
  19.             while(c >= (y = tate_org_font_list[x])) {
  20.                 if (y == c) {
  21.                     register STR p;
  22.  
  23.                     p = &tate_org_font_data[x*24*3];
  24.                     for(x=0;x<24*3;x++) {
  25.                         *dp++ = *p++;
  26.                     }
  27.                     return;
  28.                 }
  29.                 x++;
  30.             }
  31.         }
  32.         if (c <= L'╂') {
  33.             x = 0;
  34.             while(c >= (y = tate_not_list[x++])) {
  35.                 if (y == c) {
  36.                     return;
  37.                 }
  38.             }
  39.         }
  40.  
  41.         for(x=0;x<24*3;x++) {
  42.             w0[x] = dp[x];    /* コピー */
  43.             dp[x] = 0;    /* ERASE */
  44.         }
  45.         for(x=0;x<24;x++) {
  46.             x8 = x/8;
  47.             mask = (128 >> (x % 8));
  48.             for(y=0;y<24;y++) {
  49.                 if (w0[y*3+x8] & mask) {
  50.                     dp[(23-x)*3+(y/8)] |= (128 >> (y % 8));
  51.                 }
  52.             }
  53.         }
  54.     }
  55. }
  56.  
  57. UBYTE
  58. etc_last(UBYTE *p)
  59. {
  60.     if (*p) {
  61.         return(p[strlen(p)-1]);
  62.     } else {
  63.         return(EOS);
  64.     }
  65. }
  66.  
  67. /* 文字列の最後の文字を返す */
  68. /* 全角文字にも対応 */
  69. UWORD
  70. etc_jlast_p(STR s,STR *p)
  71. {
  72.     register UWORD c,c0,lc;
  73.     register STR p0;
  74.  
  75.     lc = 0;
  76.     p0 = s;
  77.     while(c = *s++) {
  78.         p0 = s-1;
  79.         if (string_1or2_byte_code(c)-1) {    /* ２バイトコードの１バイト目なら */
  80.             if (c0 = *s++) {
  81.                 lc = (c << 8) | c0;
  82.             } else {
  83.                 error("奇妙な文字列を処理しようとしました");
  84.             }
  85.         } else {            /* １バイトコードなら */
  86.             lc = c;
  87.         }
  88.     }
  89.     *p = p0;
  90.     return(lc);
  91. }
  92.  
  93. /* 文字列の最後の文字を返す */
  94. /* 全角文字にも対応 */
  95. UWORD
  96. etc_jlast(STR s)
  97. {
  98.     register UWORD c,c0,lc;
  99.  
  100.     lc = 0;
  101.     while(c = *s++) {
  102.         if (string_1or2_byte_code(c)-1) {    /* ２バイトコードの１バイト目なら */
  103.             if (c0 = *s++) {
  104.                 lc = (c << 8) | c0;
  105.             } else {
  106.                 error("奇妙な文字列を処理しようとしました");
  107.             }
  108.         } else {            /* １バイトコードなら */
  109.             lc = c;
  110.         }
  111.     }
  112.     return(lc);
  113. }
  114.  
  115. /* 最初の１文字を返す */
  116. /* 全角対応 */
  117. UINT
  118. etc_jfirst(STR s)
  119. {
  120.     register UINT c;
  121.  
  122.     if (iskanji(c = *s)) {
  123.         c = (c << 8) | s[1];
  124.     } else {
  125.         if ((c == 0x80) || (c == 0xf0) || (c == 0xf1) || (c == 0xf2) || (c == 0xf3)) {
  126.             c = (c << 8) | s[1];
  127.         }
  128.     }
  129.     return(c);
  130. }
  131.  
  132.     /* ２文字目へのポインタを返す */
  133. /* 最初の文字を返す */
  134. /* 全角文字にも対応 */
  135. /* EOS なら NULL を返す */
  136. STR
  137. etc_jfirst_x(STR s,UINT *cret)
  138. {
  139.     register UWORD c,c0;
  140.  
  141.     if ((!s) || !*s) {
  142.         *cret = EOS;
  143.         return((STR) NULL);
  144.     }
  145.  
  146.     if (c = *s++) {
  147.         if (string_1or2_byte_code(c)-1) {    /* ２バイトコードの１バイト目なら */
  148.             if (c0 = *s++) {
  149.                 *cret = (c << 8) | c0;
  150.                 return(s);
  151.             } else {
  152.                 *cret = c;
  153.                 return(s-1);
  154.             }
  155.         } else {            /* １バイトコードなら */
  156.             *cret = c;
  157.             return(s);
  158.         }
  159.     } else {
  160.         return((STR) NULL);
  161.     }
  162. }
  163.  
  164. /* i バイト目を越えない最後の文字を返す */
  165. /* 全角文字にも対応 */
  166. UWORD
  167. etc_j_n_char(STR s,int i)
  168. {
  169.     register UWORD c,c0,lc;
  170.  
  171.     lc = 0;
  172.     while((c = *s++) && (i--)) {
  173.         if (string_1or2_byte_code(c)-1) {    /* ２バイトコードの１バイト目なら */
  174.             if (c0 = *s++) {
  175.                 i--;
  176.                 lc = (c << 8) | c0;
  177.             } else {
  178.                 error("奇妙な文字列を処理しようとしました");
  179.             }
  180.         } else {            /* １バイトコードなら */
  181.             lc = c;
  182.         }
  183.     }
  184.     return(lc);
  185. }
  186.  
  187. int
  188. etc_iocs(int d0,int d1, int d2)
  189. {
  190. #asm
  191.     move.l 4(sp),d0
  192.     move.l 8(sp),d1
  193.     move.l 12(sp),d2
  194.     trap #15
  195.     rts
  196. #endasm
  197. }
  198.  
  199. void
  200. etc_dump_screen()
  201. {
  202.     int i;
  203.     UNIT *p;
  204.  
  205.     for(i=0;i<YWIDTH-1;i++) {
  206.         window_abs_loc(32,i);
  207.         if ((p = SCREEN[i]) == TAIL) {
  208.             B_PRINT(" TAIL ");
  209.         } else if (p == NIL) {
  210.             B_PRINT(" NIL  ");
  211.         } else if (p == NOT) {
  212.             B_PRINT(" NOT  ");
  213.         } else {
  214.             UBYTE db[VERY_LONG_LINE];
  215.             cut_disp_convert(p->BODY,db,CURRENT_JIZUME);
  216.             B_PRINT(db);
  217.         }
  218.     }
  219.     work_cursor_cpx();
  220. }
  221.  
  222. void
  223. etc_dump_cut_buff()
  224. {
  225.     UBYTE db[VERY_LONG_LINE];
  226.     UNIT *p;
  227.     int y;
  228.  
  229.     init_clear_screen();
  230.     p = CUT_BUFF_HEAD;
  231.  
  232.     for(y = 0;y < YWIDTH0;y++) {
  233.         if (!p) break;
  234.         disp_1line(y,p);
  235.         p = p->ATO;
  236.     }
  237.     getchar();
  238. }
  239.  
  240. int
  241. etc_sign(int i)
  242. {
  243.     if (i) {
  244.         return((i<0) ? -1:1);
  245.     } else {
  246.         return(0);
  247.     }
  248. }
  249.  
  250. /*
  251. TPLANE        equ    $944    *L    テキストプレーン ($E00000:TXT0)
  252. TOFS        equ    $948    *L    テキストプレーン表示位置オフセット (0)
  253.  
  254. CRT_DOUJI    equ    $E8_002A    ; CRT 同時アクセス
  255. */
  256.  
  257.  
  258. /* ボックス消去 */
  259. /* x0, x1 = キャラ座標 */
  260. /* y0, yw = ドット座標 */
  261. void
  262. etc_era_box(int x0,int y0,int x1,int yw)
  263. {
  264. #asm
  265. TPLANE        equ    $944
  266. TOFS        equ    $948
  267.  
  268. CRT_DOUJI    equ    $E8_002A
  269.     movem.l    d0-d4/a1,era_save
  270.  
  271.     moveq.l    #$81,d0        * to super
  272.     clr.l    a1
  273.     trap    #15
  274.     move.l    d0,era_save_ssp
  275.  
  276.     move.l 4(sp),d0        * x0
  277.     move.l 12(sp),d2    * x1
  278.  
  279. * <-        128        ->
  280. * <-        d2    ->
  281. * <-    d0    ->
  282. * AAAAAAAAAAAAAAAAXXXXXXXX
  283. * AAAAAAAAAAAAAAAA
  284. * 128 - d2 + d0 -1
  285.     move.l    #128-1,d4
  286.     add.w    d0,d4
  287.     sub.w    d2,d4        * d4 = スキップバイトカウンタ
  288.  
  289.     sub.l    d0,d2
  290.     ble    era_exit    * 始まりと終わりが同じ位置
  291.  
  292.     move.l 16(sp),d3    * yw
  293.     beq    era_exit    * 縦幅０
  294.  
  295.     move.l 8(sp),d1        * y0
  296.  
  297. *     d2.w:消去桁数
  298. *    d0.l:消去開始位置
  299.  
  300.     asl.l    #7,d1        * ×（１０２４／８）：行方向オフセット計算
  301.     add.l    d0,d1        * 桁方向オフセット加算
  302. *    add.l    TOFS,d1        * 表示開始位置オフセット加算
  303.     add.l    TPLANE,d1    * 対象テキストプレーン
  304.     movea.l    d1,a1
  305. *    a1.l:TVRAM アドレス
  306.     subq.l    #1,d3
  307. *    d3.w:消去する縦幅
  308. *    d4.w:スキップバイトカウンタ
  309.     bset.b    #0,CRT_DOUJI    * 同時アクセス on
  310.  
  311.     clr.w    d0        * 通常用消去データプリセット
  312.  
  313. era1_y_loop:
  314.     move.w    d2,d1        * ループカウンタ初期化
  315.  
  316. era1_x_loop:
  317.     move.b    d0,(a1)+    * 消去データ書き込み
  318.     dbf    d1,era1_x_loop    * 内ループ
  319.  
  320.     adda.l    d4,a1        * 次ライン
  321.     dbf    d3,era1_y_loop
  322.  
  323.     bclr.b    #0,CRT_DOUJI    * 同時アクセス off
  324. era_exit
  325.     moveq.l    #$81,d0
  326.     movea.l    era_save_ssp,a1
  327.     trap    #15
  328.  
  329.     movem.l    era_save,d0-d4/a1
  330.     rts
  331.  
  332.     .data
  333.     .even
  334. era_save
  335.     ds.l    6
  336. era_save_ssp
  337.     ds.l    1
  338.  
  339. #endasm
  340. }
  341.  
  342.  
  343. int
  344. etc_get_arg()
  345. {
  346.     int a;
  347.  
  348.     a = ARG;
  349.     ARG = 0;
  350. /*    under_blanc();*/
  351.     return(a);
  352. }
  353.  
  354. void
  355. etc_set_arg(int a)
  356. {
  357.     UBYTE w[MAXLINE];
  358.  
  359.     ARG = a;
  360.     sprintf((char *) w,"Arg: %u",a);
  361.     under_print0(w);
  362. }
  363.  
  364. void
  365. etc_set_ed_arg(int a)
  366. {
  367.     UBYTE w[MAXLINE];
  368.  
  369.     ARG = a;
  370.     sprintf((char *) w,"*%u",a);
  371.     under_print0(w);
  372. }
  373.  
  374. void
  375. etc_push_arg(int a)
  376. {
  377.     ARG = a;
  378. }
  379.  
  380. /* コードから、文字の種類を判別する */
  381. UWORD
  382. etc_check_char_kind(UINT c)
  383. {
  384.     if (c >= 0x100) {
  385.         c >>= 8;
  386.     }
  387.     return(etc_check_char_kind_1byte(c));
  388. }
  389.  
  390. #define    BYTE1_MASK    0b000010011
  391. #define    BYTE2_MASK    0b011101100    /* ただし XCODE の一部は２バイト */
  392.  
  393. #define    HABA0_MASK    0b100000000
  394. #define    HABA1_MASK    0b001010110
  395. #define    HABA2_MASK    0b010101001
  396.  
  397. /* １バイトから、文字の種類を判別する */
  398. /* XCODE | 謎のコード | 2byte半角の上 | ２水 | カタカナ | １水 | 2byte半角の下 | ANK | CTRL */
  399. /*             （１／４角）                 半角ひらがな */
  400. /* EX:    1byte 000010011 */
  401. /*    haba0 100000000 */
  402. /*    haba1 001010110 */
  403. /*    haba2 010101001 */
  404. UWORD
  405. etc_check_char_kind_1byte(register UBYTE c)
  406. {
  407.     if (c < 0x20) {
  408.         return(0b1);
  409.     } else if (c < 0x80) {
  410.         return(0b10);
  411.     } else if (c == 0x80) {
  412.         return(0b100);
  413.     } else if (c < 0xa0) {
  414.         return(0b1000);
  415.     } else if (c < 0xe0) {
  416.         return(0b10000);
  417.     } else if (c < 0xf0) {
  418.         return(0b100000);
  419.     } else if (c < 0xf4) {
  420.         return(0b1000000);
  421.     } else if (c < XCODE_UP) {
  422.         return(0b10000000);
  423.     } else {
  424.         return(0b100000000);
  425.     }
  426. }
  427.  
  428. /* ポインタの指しているところの文字のバイト幅を返す */
  429. /* 1,2 */
  430. UINT
  431. etc_char_byte_haba(STR p)
  432. {
  433.     if (BYTE1_MASK & etc_check_char_kind_1byte(*p)) {
  434.         return(1);
  435.     } else {
  436.         return(2);
  437.     }
  438. }
  439.  
  440. /* ポインタの指しているところの文字の表示幅を返す */
  441. /* 0,1,2 */
  442. UINT
  443. etc_char_disp_haba(STR p)
  444. {
  445.     register UBYTE c;
  446.  
  447.     if (c == *p) {
  448.         if (HABA1_MASK & etc_check_char_kind_1byte(c)) {
  449.             return(1);
  450.         } else {
  451.             return(2);
  452.         }
  453.     } else {
  454.         return(0);
  455.     }
  456. }
  457.  
  458. /* 文字のバイト幅を返す */
  459. /* 1,2 */
  460. UINT
  461. etc_char_byte_len(UINT c)
  462. {
  463.     return((c >= 0x100) ? 2:1);
  464. }
  465.  
  466. /* 文字の表示幅を返す */
  467. /* 0,1,2 */
  468. UINT
  469. etc_char_disp_len(UINT c)
  470. {
  471.     if (c) {
  472.         if (c >= 0x100) {
  473.             c >>= 8;
  474.         }
  475.         if (HABA1_MASK & etc_check_char_kind_1byte(c)) {
  476.             return(1);
  477.         } else {
  478.             return(2);
  479.         }
  480.     } else {
  481.         return(0);
  482.     }
  483. }
  484.  
  485. UINT
  486. inkey()
  487. {
  488.     disp_cursor_on();
  489.     disp_show_cursor();
  490.     return(fep_inkey());
  491. }
  492.  
  493. #if 0
  494.  
  495. void
  496. dinkey()
  497. {
  498.     UINT c;
  499.  
  500.     etc_beep();
  501.     while(1) {
  502.         if ((c = fep_inkey_raw()) == (UINT) ('C'-'@')) {
  503.             ctrl_x_ctrl_c();
  504.         }
  505.         if (c == '.') {
  506.             break;
  507.         } else {
  508.             putchar(c);
  509.         }
  510.     }
  511. }
  512.  
  513. void
  514. wbinkey()
  515. {
  516.     etc_while_fep_qxf();
  517.     binkey();
  518. }
  519.  
  520. UINT
  521. inkey0()
  522. {
  523.     return(fep_inkey());
  524. }
  525.  
  526. void
  527. binkey0()
  528. {
  529.     etc_beep();
  530.     if (inkey0() == (UINT) ('C'-'@')) {
  531.         etc_exit(0);
  532.     }
  533. }
  534. #endif
  535.  
  536. #if 0
  537.  
  538. void
  539. upr(STR s)
  540. {
  541.     under_print(s);
  542. }
  543.  
  544. void
  545. upr0(STR s)
  546. {
  547.     under_blanc();
  548. }
  549.  
  550. void
  551. uprb(STR s)
  552. {
  553.     under_print(s);
  554.     binkey();
  555. }
  556.  
  557. void
  558. upr0b(STR s)
  559. {
  560.     under_blanc();
  561.     binkey();
  562. }
  563. #endif
  564.  
  565. /* ２点の順序を整える */
  566. /* エラーなら０を返す */
  567. int
  568. etc_line_order(UNIT **p1,int *bp1,UNIT **p2,int *bp2)
  569. {
  570.     register UNIT *wp1,*wp2;
  571.  
  572.     if ((wp1 = *p1) == (wp2 = *p2)) {    /* 同じ行である */
  573.         if (*bp1 > *bp2) {
  574.             /* 交換 */
  575.             register int w;
  576.             w = *bp1;
  577.             *bp1 = *bp2;
  578.             *bp2 = w;
  579.         }
  580.         return(1);
  581.     }
  582.  
  583.     do {    /* まずは p1 から */
  584.         if (wp1 == wp2) {
  585.             return(1);
  586.         }
  587.     } while(wp1 = wp1->ATO);
  588.  
  589.     wp1 = *p1;
  590.     do {    /* 次に p2 から */
  591.         if (wp2 == wp1) {
  592.             register int w;
  593.  
  594.             /* 交換 */
  595.             *p1 = *p2;
  596.             *p2 = wp1;
  597.             w = *bp1;
  598.             *bp1 = *bp2;
  599.             *bp2 = w;
  600.             return(1);
  601.         }
  602.     } while(wp2 = wp2->ATO);
  603.  
  604.     return(0);
  605. }
  606.  
  607. int
  608. etc_set_tab(int n)
  609. {
  610.     if (TAB_LENGTH != n) {
  611.         TAB_LENGTH = n;
  612.             TAB_LENGTH_1 = TAB_LENGTH - 1;
  613.         return(1);
  614.     } else {
  615.         return(0);
  616.     }
  617. }
  618.  
  619. void
  620. lddr(STR d,STR s,int i)
  621. {
  622.     register int c = i;
  623.     register STR dest = d+i;
  624.     register STR sour = s+i;
  625.  
  626.     for(;c>0;c--) {
  627.         *--dest = *--sour;
  628.     }
  629. }
  630. /*
  631. void
  632. dumper(STR s)
  633. {
  634.     int i;
  635.  
  636.     window0();
  637.     i = min(40,strlen(s));
  638.     printf("dumper:");
  639.     for(;i>0;i--) {
  640.         printf("%x:",*s++);
  641.     }
  642.     binkey();
  643. }
  644. */
  645.  
  646.  
  647. #define    click_size    32
  648. #define    click_cl    4
  649. #define    click_mode    3
  650. #define    click_length    32
  651.  
  652. UBYTE click_buf[click_size] = {
  653. 0x1f,0x1f,0x3f,0x3f,0x1f,0x1f,0x3f,0x3f,
  654. 0x1f,0x1f,0x3f,0x3f,0x1f,0x1f,0x3f,0x3f,
  655. 0x1f,0x1f,0x3f,0x3f,0x1f,0x1f,0x3f,0x3f};
  656.  
  657. void
  658. etc_click()
  659. {
  660.     if (CLICK_MODE) {
  661.         a_play(click_buf,click_size,click_cl,click_mode,click_length);
  662.     }
  663. }
  664.  
  665. struct NAMECKBUF INF;
  666.  
  667. UBYTE INF_drive[3];
  668.  
  669. /* 名前情報を分解する */
  670. int
  671. etc_set_INF(STR file)
  672. {
  673.     int r;
  674.  
  675.     r = NAMECK(file,&INF);
  676.     strncpy(INF_drive,INF.drive,2);
  677.     INF_drive[2] = EOS;
  678.     return(r);
  679. }
  680.  
  681. void
  682. etc_get_pathname(STR pathname,STR file)
  683. {
  684.     if (etc_set_INF(file) < 0) {
  685.         *pathname = EOS;
  686.         return;
  687.     }
  688.  
  689.     strcpy(pathname,INF_drive);
  690.     strcat(pathname,INF.path);
  691.     strcat(pathname,INF.name);
  692.     strcat(pathname,INF.ext);
  693. }
  694.  
  695. void
  696. etc_get_pathname_bak(STR pathname,STR file)
  697. {
  698.     etc_set_INF(file);
  699.  
  700.     strcpy(pathname,INF_drive);
  701.     strcat(pathname,INF.path);
  702.     strcat(pathname,INF.name);
  703.     strcat(pathname,".BAK");
  704. }
  705.  
  706. /* name から、フルパスの暫定ファイル名を得る */
  707. void
  708. etc_get_tname(STR tname,STR file)
  709. {
  710.     UBYTE pri[MAXLINE];
  711.     STR tn;
  712.  
  713.     etc_set_INF(file);        /* パーツ分解 */
  714.     strcpy((char *)tname,(char *)INF_drive);    /* ドライブ名を得る */
  715.     strcat((char *)tname,(char *)INF.path);        /* パスを得る */
  716.     if (tn = (STR) tempnam((char *)tname,"tw")) {
  717.         strcpy((char *)tname,(char *)tn);
  718.     } else {
  719.         under_print0((STR)"暫定ファイル名を作れないのでセーブ出来ません[Y]?");
  720.         etc_beep();
  721.         etc_wait_y();
  722.         *tname = EOS;
  723.     }
  724. }
  725.  
  726. UBYTE etc_path[MAXLINE];
  727.  
  728. STR
  729. etc_ret_current_path()
  730. {
  731.     etc_set_INF("");
  732.  
  733.     strncpy(etc_path,INF.drive,2);
  734.     etc_path[2] = EOS;
  735.     strcat(etc_path,INF.path);
  736. }
  737.  
  738. /*
  739. void
  740. etc_get_pathpri(STR pathpri,STR file)
  741. {
  742.     struct NAMECKBUF INF;
  743.  
  744.     NAMECK(file,&INF);
  745.     strncpy(pathpri,INF.drive,2);
  746.     pathpri[2] = EOS;
  747.     strcat(pathpri,INF.path);
  748.     strcat(pathpri,INF.name);
  749. }
  750.  
  751. void
  752. etc_get_pri(STR pri,STR file)
  753. {
  754.     struct NAMECKBUF INF;
  755.  
  756.     NAMECK(file,&INF);
  757.     strcpy(pri,INF.name);
  758. }
  759. */
  760.  
  761. UWORD FUNC_FLAG = 1;    /* 初期値では、表示されている */
  762.  
  763. void
  764. etc_func_on()
  765. {
  766.     if (!FUNC_FLAG) {        /* 表示されてないなら */
  767.         etc_func_on0();        /* 表示する */
  768.     }
  769. }
  770. void
  771. etc_func_off()
  772. {
  773.     if (FUNC_FLAG) {        /* 表示されているなら */
  774.         etc_func_off0();    /* を消す */
  775.     }
  776. }
  777. /* ファンクションキー表示をする */
  778. void
  779. etc_func_on0()
  780. {
  781.     FUNC_FLAG = 1;
  782. #asm
  783. CONCTRL    equ    $ff23
  784.     move.w    #0,-(sp)
  785.     move.w    #14,-(sp)
  786.     DC.W    CONCTRL
  787.     addq.l    #4,sp
  788. #endasm
  789. }
  790.  
  791. /* ファンクションキー表示を消す */
  792. void
  793. etc_func_off0()
  794. {
  795.     FUNC_FLAG = 0;
  796. #asm
  797.     move.w    #2,-(sp)
  798.     move.w    #14,-(sp)
  799.     DC.W    CONCTRL
  800.     addq.l    #4,sp
  801. #endasm
  802. }
  803.  
  804. /* 与えられたコードを積極的にスペースに修正する */
  805. UINT
  806. etc_normal_jis(UINT a)
  807. {
  808.     unsigned int b,c;
  809.  
  810.     if (a < 0x100) {
  811.         return(a);
  812.     } else if (buff_ishan2byte(a >> 8)) {
  813.         return(a);
  814.     }
  815.  
  816.     b = JISSFT(SFTJIS(a));
  817.     if (a == b) {    /* ２度変換して元に戻った */
  818.         return(a);
  819.     } else {
  820.         return(L'　');    /* 空白を返す */
  821.     }
  822. }
  823.  
  824. /* 与えられたファイル番号を持つテキスト番号を捜す */
  825. /* 無ければ－１を返す */
  826. int
  827. etc_text_search(int f)
  828. {
  829.     register int tn;
  830.  
  831.     for(tn=0;tn<MAX_TEXT;tn++) {
  832.         if (TDATA[tn].TEXT_FILE == f) {
  833.             return(tn);
  834.         }
  835.     }
  836.     return(-1);
  837. }
  838.  
  839. int
  840. etc_group(UINT c)
  841. {
  842.     if (c < 0x100) {    /* 半角 */
  843.         if (!isalnmkana(c)) {    /* 英数字でもカナでもない */
  844.             return(0);    /* コントロールと記号 */
  845.         } else if (isalnum(c)) {/* 英数字だ */
  846.             return(1);
  847.         } else {        /* それ以外だ（多分カナ） */
  848.             return(2);
  849.         }
  850.     } else if (c < 0x8140) {    /* 半角２バイト文字だ */
  851.         return(3);
  852.     } else if (c < 0x824f) {    /* 全角の記号だ */
  853.         if ((L'ー' <= c) && (c <= L'‐')) {
  854.             return(5);        /* !!! */
  855.         } else {
  856.             return(0);
  857.         }
  858.     }
  859.     return(5);
  860. }
  861.  
  862. /*
  863. ))))））））aaaＡＡＡaaa￥￥￥￥￥：：：：：
  864. */
  865.  
  866. UINT
  867. etc_tolower(UINT c)
  868. {
  869.     if (c < 0x100) {
  870.         return(tolower(c));
  871.     } else if (jisupper(c)) {
  872.         return(c - ((UINT)L'Ａ' - (UINT)L'ａ'));
  873.     }
  874.     return(c);
  875. }
  876.  
  877. UINT
  878. etc_toupper(UINT c)
  879. {
  880.     if (c < 0x100) {
  881.         return(toupper(c));
  882.     } else if (jislower(c)) {
  883.         return(c + ((UINT)L'Ａ' - (UINT)L'ａ'));
  884.     }
  885.     return(c);
  886. }
  887.  
  888. UBYTE handakuten_list[] = "はひふへほハヒフヘホ";
  889. UBYTE dakuten_list[] = "かきくけこさしすせそたちつてとはひふへほ\\
  890. カキクケコサシスセソタチツテトハヒフヘホ";
  891. UINT
  892. etc_handakuten_able()
  893. {
  894.     UINT c;
  895.  
  896.     ctrl_b();
  897.     c = line_cpx_code();
  898.     if (jstrchr(handakuten_list,c)) {
  899.         return(c+2);
  900.     } else {
  901.         ctrl_f();    /* 戻して */
  902.         return(0);
  903.     }
  904. }
  905.  
  906. UINT
  907. etc_dakuten_able_under(UWORD c)
  908. {
  909.     return(jstrchr(dakuten_list,c));
  910. }
  911.  
  912. UINT
  913. etc_handakuten_able_under(UWORD c)
  914. {
  915.     return(jstrchr(handakuten_list,c));
  916. }
  917.  
  918. UINT
  919. etc_dakuten_able()
  920. {
  921.     UINT c;
  922.  
  923.     ctrl_b();
  924.     c = line_cpx_code();
  925.     if (jstrchr(dakuten_list,c)) {
  926.         return(c+1);
  927.     } else {
  928.         ctrl_f();    /* 戻して */
  929.         return(0);
  930.     }
  931. }
  932.  
  933. /* CR を <NL> にしたり、コントロールコードを ^? にしたりする */
  934. void
  935. etc_string_esc_cnv(STR s,STR d)
  936. {
  937.     register UBYTE c;
  938.  
  939.     while(c = *s++) {
  940.         if (c < 0x20) {
  941.             if (c == 'J'-'@') {
  942.                 strncpy(d,"<NL>",4);
  943.                 d += 4;
  944.             } else {
  945.                 *d++ = '^';
  946.                 *d++ = c + '@';
  947.             }
  948.             
  949.         } else {
  950.             *d++ = c;
  951.             if (etc_check_char_kind_1byte(c) & BYTE2_MASK) {
  952.                 *d++ = *s++;
  953.             }
  954.         }
  955.     }
  956.     *d = EOS;
  957. }
  958.  
  959. int
  960. etc_str_han_to_zen(STR d0,STR s,int size)
  961. {
  962.     UINT c;
  963.     register UINT c0;
  964.     register STR d;
  965.     UBYTE w[VERY_LONG_LINE];
  966.     int flag;
  967.  
  968.     d = w;
  969.     while(s = etc_jfirst_x(s,&c)) {
  970.         flag = 0;
  971.         if (c >= 0x100) {
  972.             if ((0x8000 <= c) && (c <= 0x80df)) {
  973.                     /* 半角２バイト英数字、ひらがな */
  974.  
  975.                 c &= 0xff;    /* いったんｶﾀｶﾅへ */
  976.                 flag = 1;
  977.             } else {
  978.                 *d++ = (UBYTE)(c>>8);    /* 上位バイト */
  979.                 *d++ = (UBYTE)c;    /* 下位バイト */
  980.                 continue;
  981.             }
  982.         }
  983.         c0 = hantozen(c);
  984.         if (c0 == c) {                /* 変換されなかった */
  985.             *d++ = (UBYTE)c0;        /* １バイト */
  986.         } else {                /* 変換された */
  987.             if (flag) {
  988.                 c0 = etc_zen_kata_to_hira1(c0);
  989.             }
  990.             if (*s == (UBYTE)'ﾞ') {
  991.                 if (jstrchr(dakuten_list,c0)) {    /* 濁点にできる */
  992.                     c0++;
  993.                     s += 1;
  994.                 }
  995.             } else if ((s[0] == 0x80) && (s[1] == 0xde)) {    /* 次が２バイト濁点だ */
  996.                     c0++;
  997.                     s += 2;
  998.             } else if (*s == (UBYTE)'ﾟ') {        /* 次が半濁点だ */
  999.                 if (jstrchr(handakuten_list,c0)) {    /* 濁点にできる */
  1000.                     c0 += 2;
  1001.                     s += 1;
  1002.                 }
  1003.             } else if ((s[0] == 0x80) && (s[1] == 0xdf)) {    /* 次が２バイト濁点だ */
  1004.                     c0 += 2;
  1005.                     s += 2;
  1006.             }
  1007.             *d++ = (UBYTE)(c0 >> 8);    /* 上位バイト */
  1008.             *d++ = (UBYTE)c0;        /* 下位バイト */
  1009.         }
  1010.     }
  1011.     *d = EOS;
  1012.     if (strlen(w) > MAX_TB) {
  1013.         etc_beep();
  1014.         under_print("全角へ変換する文字列が長すぎます");
  1015.         return(1);
  1016.     } else {
  1017.         strcpy(d0,w);
  1018.         return(0);
  1019.     }
  1020. }
  1021.  
  1022.  
  1023. int
  1024. etc_str_zen_to_han(STR d0,STR s,int size)
  1025. {
  1026.     UINT c;
  1027.     register UINT c0;
  1028.     register STR d;
  1029.     UBYTE w[MAXLINE];
  1030.  
  1031.     d = w;
  1032.     while(s = etc_jfirst_x(s,&c)) {
  1033.         if (c < 0x100) {
  1034.             *d++ = c;
  1035.             continue;
  1036.         }
  1037.         c0 = zentohan(c);
  1038.         if (c0 == c) {                /* 変換されなかった */
  1039.             if (c0 & 0xff00) {        /* ２バイトだ */
  1040.                 *d++ = (UBYTE)(c0>>8);    /* 上位バイト */
  1041.             }
  1042.             *d++ = (UBYTE)c0;        /* 下位バイト */
  1043.         } else {                /* 変換された */
  1044.             *d++ = (UBYTE)c0;        /* 下位バイト */
  1045.             if (c0 & 0xff00) {        /* ２バイトだ（濁点、半濁点がある） */
  1046.                 *d++ = (UBYTE)(c0 >> 8);    /* 上位バイト */
  1047.             }
  1048.         }
  1049.     }
  1050.     *d = EOS;
  1051.     strcpy(d0,w);
  1052.     return(0);
  1053. }
  1054.  
  1055.  
  1056.  
  1057.  
  1058. int
  1059. etc_just_kaigyou(UNIT *wp)
  1060. {
  1061.     UBYTE w[VERY_LONG_LINE];
  1062.  
  1063.     line_get_body(w,wp);
  1064.     return(*line_skip_xcode(w) == CR);
  1065. }
  1066. #if 0
  1067. void
  1068. etc_om_exit()
  1069. {
  1070.     under_print0((STR)"ファイルの途中までしか読み込めません。中断します [Y]? ");
  1071.     etc_y_exit();
  1072. }
  1073. #endif
  1074. void
  1075. etc_y_exit()
  1076. {
  1077.     UBYTE c;
  1078.  
  1079.     fep_key_clear();
  1080.     while(1) {
  1081.         etc_beep();
  1082.         c = toupper(fep_inkey_raw());
  1083.         if (c == 'Y') {
  1084.             init_exit();
  1085.             etc_exit(0);
  1086.         }
  1087.     }
  1088. }
  1089.  
  1090. etc_inp_y(STR mess)
  1091. {
  1092.     UBYTE c;
  1093.  
  1094.     under_print0(mess);
  1095.     while(1) {
  1096.         etc_beep();
  1097.         c = toupper(fep_inkey_raw());
  1098.         if (c == 'Y') {
  1099.             return;
  1100.         }
  1101.     }
  1102. }
  1103.  
  1104. STR
  1105. etc_jstrup(STR s)
  1106. {
  1107.     register STR p;
  1108.     register UBYTE c;
  1109.  
  1110.     p = s;
  1111.     while(c = *p) {
  1112.         if (iskanji(c) || (c == XCODE_UP)) {
  1113.             p += 2;
  1114.         } else {
  1115.             *p++ = toupper(c);
  1116.         }
  1117.     }
  1118.     return(s);
  1119. }
  1120.  
  1121. STR
  1122. etc_name_to_full(STR s)
  1123. {
  1124.     UBYTE w[MAXLINE];
  1125.  
  1126.     etc_get_pathname(w,s);
  1127.     strcpy(s,w);
  1128.     return(s);
  1129. }
  1130.  
  1131. /* 変更を受けている */
  1132. int
  1133. etc_check_changed()
  1134. {
  1135.     register int t;
  1136.  
  1137.     for(t=0;t<MAX_TEXT;t++) {
  1138.         if ((TDATA[t].TEXT_FILE >= 0) && (TDATA[t].CHANGED_FLAG)) {
  1139.             return(1);
  1140.         }
  1141.     }
  1142.     return(0);
  1143. }
  1144.  
  1145. #define    HumanST    0x6800
  1146.  
  1147. UBYTE nname[9] = "NUL     ";
  1148. UBYTE cname[9] = "CON     ";
  1149.  
  1150. /* 最後に組み込まれている con を得る */
  1151. UINT
  1152. etc_get_last_con()
  1153. {
  1154.     register int a0,a1;
  1155.     register int i;
  1156.     UINT lcon = 0;
  1157.  
  1158.     if (DUM_FLAG) {
  1159.         return(0);
  1160.     }
  1161.  
  1162.     a0 = HumanST;
  1163.     a1 = nname;
  1164.     while(1) {
  1165.         while(1) {
  1166.             while(B_WPEEK(a0) != (('N'<<8) |'U')) {
  1167.                 a0 += 2;
  1168.             }
  1169.             if ((B_LPEEK(a0) == B_LPEEK(a1))
  1170.              && (B_LPEEK(a0+4) == B_LPEEK(a1+4))) {    /* 一致 */
  1171.                 break;
  1172.             } else {
  1173.                 a0 += 2;
  1174.             }
  1175.         }    /* デバイス「NULL」をさがす */
  1176.  
  1177.         if (a0 >= a1) {
  1178.             error("ＣＯＮデバイスが異常です");
  1179.         }
  1180.         a0 += 2;
  1181.         if (B_WPEEK(a0-18) != 0x8024) {
  1182.             break;
  1183.         }
  1184.     }
  1185.     a0 -= 16;
  1186.     while(1) {
  1187.         a1 = a0+14;    /* name */
  1188.         for(i=0;i<8;i++) {
  1189.             if (B_BPEEK(a1+i) != cname[i]) {
  1190.                 break;
  1191.             }
  1192.         }
  1193.         if (i == 8) {
  1194.             lcon = a0;
  1195.         }
  1196.         a0 = B_LPEEK(a0);
  1197.         if (a0 == -1) {
  1198.             break;
  1199.         }
  1200.     }
  1201.     return(lcon);
  1202. }
  1203.  
  1204. /*
  1205. _CHAR_DEV    equ    $8000        *キャラクタデバイス
  1206. _RAW        equ    $0020        *指定バイトずつ処理
  1207. _NUL        equ    $0004        *nulデバイス
  1208. */
  1209.  
  1210. void
  1211. etc_color(int c)
  1212. {
  1213.     color(c);
  1214.     CTCOLOR = c;
  1215. }
  1216.  
  1217. /* x,y = キャラ座標 */
  1218. /* 新しい x 座標を返す */
  1219. int
  1220. etc_bit_convert_and_disp(int x,int y,STR disp_work)
  1221. {
  1222.     UBYTE blue_mask[XWIDTH];
  1223.     register int xx;
  1224.  
  1225.     xx = etc_bit_convert(disp_work,PAT,LYW_UPPER,LYW_MAIN,LYW_UNDER,CURRENT_JIZUME,x,blue_mask)
  1226.          - CUT_GETA;
  1227.     /* 変換する */
  1228.     disp_cursor_off();
  1229.     etc_put_pattern(x,y*LYW_TOTAL,PAT,blue_mask);
  1230.     return(xx+x);
  1231. }
  1232.  
  1233. /* CUT_GETA + 表示幅を返す */
  1234. int
  1235. etc_bit_convert(STR s,UBYTE *pat,int upw,int mw,int dnw,int jj,int x,STR blue_mask)
  1236. {
  1237. #asm
  1238.  
  1239. XCODE_UP    equ    $0ff    * 拡張コードの開始
  1240.  
  1241. XCODE_MARK    equ    $020    * マーク 0x20 - 0x29
  1242. XCODE_SYSMARK    equ    $030    * システムマーク 0x30 - 0x3f
  1243. XCODE_MARKLAST    equ    $03f    * マークの最後
  1244.  
  1245. XCODE_UL    equ    $040    * 下線
  1246.  
  1247. XCODE_RB10    equ    $050    * 予約：１文字真ん中ルビ
  1248. XCODE_RB1    equ    $051    * １文字ルビ（半角用）
  1249. XCODE_RB1L    equ    $052    * １文字ルビ左（全角用）
  1250. XCODE_RB1R    equ    $053    * １文字ルビ右（全角用）
  1251. XCODE_RB2    equ    $054    * ２文字ルビ（全角用）
  1252.  
  1253. XWIDTH        equ    96
  1254.  
  1255.     movem.l    d1-d7/a0-a6,sdl_save
  1256.  
  1257.     move.l    4(sp),a0
  1258. * a0 = pointer to string
  1259.     move.l    8(sp),a1
  1260. * a1 = pointer to store
  1261.     move.l    32(sp),a3
  1262. * a3 = blue_mask
  1263.  
  1264.     move.l #XWIDTH-1,d0
  1265. blue_init:
  1266.     move.b #$ff,0(a3,d0)
  1267.     dbra d0,blue_init
  1268.  
  1269.     move.l #XWIDTH,d0
  1270.     sub.l 28(sp),d0        * x
  1271.     move.l d0,d6
  1272.     lsl.l #3,d0        * *8
  1273.  
  1274.     move.w    d0,(a1)+    * x size!!!
  1275.  
  1276.     move.l    12(sp),a4    * up
  1277.     move.l    16(sp),a5    * main
  1278.     move.l    20(sp),a6    * dn
  1279.     move.l    a4,d0
  1280.     add.l    a5,d0
  1281.     add.l    a6,d0
  1282.     move.w    d0,(a1)+    * y size
  1283.  
  1284.     move.l 24(sp),d5    * jizume
  1285. * d5 = jizume
  1286.  
  1287.     move.l a1,a2
  1288.     moveq.l #$81,d0        * SUPER
  1289.     movea.l #0,a1
  1290.     trap #15
  1291.     move.l d0,save_ssp
  1292.     move.l a2,a1
  1293.  
  1294.     moveq.l #0,d2
  1295.     cmpa.l    d2,a4        * up があるか？
  1296.     beq skip1
  1297.  
  1298.     move.l    a1,a4
  1299.     move.l d6,d1        * X 幅
  1300. *    move.l #8*XWIDTH/4-1,d1
  1301. * d1 = d6*2-1
  1302.     subq.l #1,d1
  1303. skip10
  1304.     move.l d2,(a1)+        * up の分を消去
  1305.     move.l d2,(a1)+        * up の分を消去
  1306.     dbra d1,skip10
  1307. *
  1308. skip1
  1309.     cmpa.l d2,a5        * main があるか？
  1310.     beq skip2
  1311.     move.l    a1,a5
  1312.     move.l d6,d1        * X 幅
  1313. * d1 = d6*4-1
  1314.     subq.l #1,d1
  1315. *    move.l #16*XWIDTH/4-1,d1
  1316. skip20
  1317.     move.l d2,(a1)+        * main の分を消去
  1318.     move.l d2,(a1)+        * main の分を消去
  1319.     move.l d2,(a1)+        * main の分を消去
  1320.     move.l d2,(a1)+        * main の分を消去
  1321.     dbra d1,skip20
  1322. *
  1323. skip2
  1324.     cmpa.l d2,a6        * dn があるか？
  1325.     beq skip3
  1326.     lea 0(a1,d6),a6        * 1 line 開けておく
  1327.     move.l d6,d1        * X 幅
  1328. * d1 = d6-1
  1329.     subq.l #1,d1
  1330. *    move.l #4*XWIDTH/4-1,d1
  1331. skip30
  1332.     move.l d2,(a1)+        * dn の分を消去
  1333.     dbra d1,skip30
  1334. *
  1335. skip3
  1336.  
  1337.     move.l _CUT_GETA,d0    * 下駄
  1338.     moveq.l #0,d7
  1339. * d0 returns disp length
  1340.  
  1341.     move.w _TAB_VIEW,d3    * #0bit = TAB flag
  1342. * TAB FLAG
  1343.  
  1344.  
  1345. USERL16:
  1346.     moveq.l #0,d1
  1347.     move.b (a0)+,d1    * まずは１バイトチェック
  1348.     bmi USERL40    * $80 以上だから２バイトコードかもしれない
  1349.     beq USERL30    * eof だから終わり
  1350.  
  1351.     cmp.b #$20,d1    * コントロールコードか？
  1352.     blt USERL16_1    * 普通の１バイト半角文字であった($20 - $7f)
  1353.  
  1354. USERL16_0:
  1355.     bsr fg_1byte_1    * その文字のパターンを持ってくる
  1356.     bra USERL16
  1357.  
  1358. *コントロールコードだ！
  1359. USERL16_1:
  1360.     cmp.b #'I'-'@',d1    * TAB
  1361.     bne USERL17
  1362.  
  1363. *0-7 -> 8, 8-15 -> 16...
  1364.     move.l d0,d4    * TAB 処理用に保存
  1365.     add.w _TAB_LENGTH,d0
  1366. * d0 から d0 mod TAB_LENGTH を引く
  1367.     move.l d0,d2    * コピー
  1368.     divu.w _TAB_LENGTH,d2
  1369.     swap d2
  1370.     sub.w d2,d0
  1371. * d0 OK
  1372.     move.l d0,d2
  1373.     sub.l d4,d2
  1374. * d2+1 が進んだ桁数
  1375.  
  1376.     subq.l #1,d2
  1377.  
  1378.     btst.l #0,d3    * 見えるかどうかのフラグチェック
  1379.     bne USERL_TAB_VIEW
  1380.  
  1381. * 見えないタブ
  1382.     move.l d4,d0
  1383.     move.l #' ',d1
  1384. U_T_LOOP1:
  1385.     move.l d3,-(sp)
  1386.     bsr fg_1byte_1
  1387.     move.l (sp)+,d3
  1388.     cmp.w d0,d5
  1389.     ble TAB_EXIT
  1390.     dbra d2,U_T_LOOP1
  1391.     bra TAB_EXIT
  1392.  
  1393. USERL_TAB_VIEW:
  1394. * 見えるタブ
  1395.     move.l d4,d0
  1396.     move.l #$801c,d1    * 半角右矢印
  1397.     move.l d3,-(sp)
  1398.     clr.b 0(a3,d7)        * blue!
  1399.     bsr fg_2byte_1
  1400.     move.l (sp)+,d3
  1401.     subq.l #1,d2
  1402.     blt USERL16
  1403.  
  1404.     move.l #$80a5,d1    * 半角中グロ
  1405. U_T_LOOP2:
  1406.     move.l d3,-(sp)
  1407.     clr.b 0(a3,d7)        * blue!
  1408.     bsr fg_2byte_1
  1409.     move.l (sp)+,d3
  1410.     cmp.w d0,d5
  1411.     ble TAB_EXIT
  1412.     dbra d2,U_T_LOOP2
  1413.  
  1414. TAB_EXIT:
  1415.     bclr.l #1,d3
  1416.     bra USERL16
  1417.  
  1418. * TAB 以外のコントロールコード
  1419. USERL17
  1420.     cmp.b #'J'-'@',d1    * CR
  1421.     bne USERL18
  1422.  
  1423. * 改行！
  1424.     move.w _KAIGYOU_HIGH,d1
  1425.     clr.b 0(a3,d7)        * blue!
  1426.     clr.b 1(a3,d7)        * blue!
  1427.     bsr fg_2byte_2
  1428.     bra USERL30    * finish
  1429.  
  1430. USERL18
  1431.     movem.l d1/d3,-(sp)    * PUSH
  1432.     move.b #'^',d1
  1433.     bsr fg_1byte_1
  1434.     movem.l (sp)+,d1/d3    * POP
  1435.     add.b #'@',d1
  1436.     bsr fg_1byte_1
  1437.     bra USERL16
  1438.  
  1439. USERL40:        * 2 byte code check
  1440.     cmp.b #$ff,d1    * xcode か？
  1441.     bne USERL405    * not xcode
  1442.  
  1443. *XCODE の処理
  1444.     move.b (a0)+,d1    * get next byte
  1445.     cmp.b #XCODE_UL,d1    * 2 byte xcode ?
  1446.     bgt USERL401
  1447.     blt USERL16    * アンダーラインより小さい（マークである）
  1448. * アンダーラインの処理
  1449.     bset.l #1,d3    * フラグをセットする
  1450.     bra USERL16
  1451.  
  1452. USERL401:
  1453.     cmp.b #XCODE_RB1R,d1
  1454.     bgt USERL403    * ２文字ルビ（全角用）
  1455.     beq USERL402    * 全角用右ルビ
  1456.     cmpi.b #XCODE_RB1,d1    * $51
  1457. *    bgt rubi_go_2left    * １文字ルビ左（全角用）
  1458.     bge rubi_go_1center    * １文字ルビ（半角用）
  1459. *１ 文字真ん中ルビ
  1460.  
  1461.     move.l a4,d1    * up があるか？
  1462.     bne rubi_go_2center
  1463.     addq.l #2,a0
  1464.     bra USERL16
  1465. rubi_go_2center:
  1466.     move.b (a0)+,d1
  1467.     lsl.w #8,d1
  1468.     move.b (a0)+,d1
  1469.     bsr fg_2byte_rb_2center
  1470.  
  1471.     bra USERL16
  1472.  
  1473. rubi_go_1center:    * １文字ルビ（半角用）
  1474. rubi_go_2left:        * １文字ルビ左（全角用）
  1475. *ここでＯＫ
  1476.     move.l a4,d1    * up があるか？
  1477.     bne rubi_go0
  1478.     addq.l #2,a0
  1479.     bra USERL16
  1480. rubi_go0:
  1481.     move.b (a0)+,d1
  1482.     lsl.w #8,d1
  1483.     move.b (a0)+,d1
  1484.     bsr fg_2byte_rb_l
  1485.  
  1486.     bra USERL16
  1487.  
  1488. USERL402:        * 全角用右ルビ
  1489.     move.l a4,d1
  1490.     bne rubi_go1
  1491.     addq.l #2,a0
  1492.     bra USERL16
  1493. rubi_go1:
  1494.     move.b (a0)+,d1
  1495.     lsl.w #8,d1
  1496.     move.b (a0)+,d1
  1497.     bsr fg_2byte_rb_r
  1498.     bra USERL16
  1499.  
  1500. USERL403:        * 2 char RUBI
  1501.     move.l a4,d1
  1502.     bne rubi_go2
  1503.     addq.l #4,a0
  1504.     bra USERL16
  1505. rubi_go2:
  1506.     move.b (a0)+,d1
  1507.     lsl.w #8,d1
  1508.     move.b (a0)+,d1
  1509.     bsr fg_2byte_rb_l
  1510.  
  1511.     move.b (a0)+,d1
  1512.     lsl.w #8,d1
  1513.     move.b (a0)+,d1
  1514.     bsr fg_2byte_rb_r
  1515.     bra USERL16
  1516.  
  1517. USERL405:        * not xcode
  1518.     cmp.b #$a0,d1
  1519.     blt USERL41    * $a0 未満である
  1520.  
  1521.     cmp.b #$e0,d1
  1522.     blt USERL16_0    * 通常の半角カタカナ
  1523.  
  1524.     cmp.b #$f0,d1    * 1/4 kaku ?
  1525.     blt USERL42    * 通常全角（２水）
  1526.     lsl.w #8,d1
  1527.     move.b (a0)+,d1
  1528.     bsr fg_2byte_1_4
  1529.     bra USERL16
  1530.  
  1531. USERL41:
  1532.     cmp.b #$80,d1    * hankaku hiragana ?
  1533.     bne USERL42
  1534.  
  1535. * 半角ひらかなである
  1536. USERL42_0:
  1537.     lsl.w #8,d1
  1538.     move.b (a0)+,d1
  1539.     bsr fg_2byte_1
  1540.     bra USERL16
  1541.  
  1542. USERL42:
  1543. * 通常全角である
  1544.     lsl.w #8,d1
  1545.     move.b (a0)+,d1
  1546.     bsr fg_2byte_2
  1547.     bra USERL16
  1548.  
  1549. USERL30:
  1550.     move.l save_ssp,a1    * old ssp
  1551.     move.l d0,save_ssp
  1552.     moveq.l #$81,d0        * SUPER
  1553.     trap #15
  1554.  
  1555.     movem.l    sdl_save,d1-d7/a0-a6
  1556.     move.l save_ssp,d0
  1557.     rts
  1558.  
  1559. fg_1byte_1:
  1560. fg_2byte_1:
  1561. fg_2byte_1_4:
  1562.     movem.l d0/d1-d2/a5,-(sp)
  1563.  
  1564.     bclr.l #1,d3    * アンダーラインフラグのチェック(破壊検査)
  1565.     beq fg_1byte_1_skip
  1566.  
  1567.     move.l a6,d0    * dn があるか？
  1568.     beq fg_1byte_1_skip
  1569.     move.b #$ff,0(a6,d7)
  1570.  
  1571. fg_1byte_1_skip:
  1572.     btst.b #3,_CTCOLOR
  1573.     bne fg_1byte_1_rev
  1574.  
  1575.     lea 0(a5,d7),a5
  1576.     moveq.l #8,d2
  1577.     moveq.l    #$16,d0    * FNTADR
  1578.     trap #15
  1579.     move.l d0,a2
  1580.  
  1581.     move.b (a2)+,(a5)
  1582.     adda.w d6,a5
  1583.     move.b (a2)+,(a5)
  1584.     adda.w d6,a5
  1585.     move.b (a2)+,(a5)
  1586.     adda.w d6,a5
  1587.     move.b (a2)+,(a5)
  1588.     adda.w d6,a5
  1589.     move.b (a2)+,(a5)
  1590.     adda.w d6,a5
  1591.     move.b (a2)+,(a5)
  1592.     adda.w d6,a5
  1593.     move.b (a2)+,(a5)
  1594.     adda.w d6,a5
  1595.     move.b (a2)+,(a5)
  1596.     adda.w d6,a5
  1597.     move.b (a2)+,(a5)
  1598.     adda.w d6,a5
  1599.     move.b (a2)+,(a5)
  1600.     adda.w d6,a5
  1601.     move.b (a2)+,(a5)
  1602.     adda.w d6,a5
  1603.     move.b (a2)+,(a5)
  1604.     adda.w d6,a5
  1605.     move.b (a2)+,(a5)
  1606.     adda.w d6,a5
  1607.     move.b (a2)+,(a5)
  1608.     adda.w d6,a5
  1609.     move.b (a2)+,(a5)
  1610.     adda.w d6,a5
  1611.     move.b (a2)+,(a5)
  1612.     adda.w d6,a5
  1613.  
  1614.     movem.l (sp)+,d0/d1-d2/a5
  1615.     addq.l #1,d0
  1616.     addq.l #1,d7
  1617.     rts
  1618.  
  1619. fg_1byte_1_rev
  1620.  
  1621.     lea 0(a5,d7),a5
  1622.     moveq.l #8,d2
  1623.     moveq.l    #$16,d0    *FNTADR
  1624.     trap #15
  1625.     move.l d0,a2
  1626.  
  1627.     moveq.l #-1,d2
  1628.  
  1629.     move.b (a2)+,d1
  1630.     eor.b d2,d1
  1631.     move.b d1,(a5)
  1632.     adda.w d6,a5
  1633.     move.b (a2)+,d1
  1634.     eor.b d2,d1
  1635.     move.b d1,(a5)
  1636.     adda.w d6,a5
  1637.     move.b (a2)+,d1
  1638.     eor.b d2,d1
  1639.     move.b d1,(a5)
  1640.     adda.w d6,a5
  1641.     move.b (a2)+,d1
  1642.     eor.b d2,d1
  1643.     move.b d1,(a5)
  1644.     adda.w d6,a5
  1645.     move.b (a2)+,d1
  1646.     eor.b d2,d1
  1647.     move.b d1,(a5)
  1648.     adda.w d6,a5
  1649.     move.b (a2)+,d1
  1650.     eor.b d2,d1
  1651.     move.b d1,(a5)
  1652.     adda.w d6,a5
  1653.     move.b (a2)+,d1
  1654.     eor.b d2,d1
  1655.     move.b d1,(a5)
  1656.     adda.w d6,a5
  1657.     move.b (a2)+,d1
  1658.     eor.b d2,d1
  1659.     move.b d1,(a5)
  1660.     adda.w d6,a5
  1661.     move.b (a2)+,d1
  1662.     eor.b d2,d1
  1663.     move.b d1,(a5)
  1664.     adda.w d6,a5
  1665.     move.b (a2)+,d1
  1666.     eor.b d2,d1
  1667.     move.b d1,(a5)
  1668.     adda.w d6,a5
  1669.     move.b (a2)+,d1
  1670.     eor.b d2,d1
  1671.     move.b d1,(a5)
  1672.     adda.w d6,a5
  1673.     move.b (a2)+,d1
  1674.     eor.b d2,d1
  1675.     move.b d1,(a5)
  1676.     adda.w d6,a5
  1677.     move.b (a2)+,d1
  1678.     eor.b d2,d1
  1679.     move.b d1,(a5)
  1680.     adda.w d6,a5
  1681.     move.b (a2)+,d1
  1682.     eor.b d2,d1
  1683.     move.b d1,(a5)
  1684.     adda.w d6,a5
  1685.     move.b (a2)+,d1
  1686.     eor.b d2,d1
  1687.     move.b d1,(a5)
  1688.     adda.w d6,a5
  1689.     move.b (a2)+,d1
  1690.     eor.b d2,d1
  1691.     move.b d1,(a5)
  1692.     adda.w d6,a5
  1693.  
  1694.     movem.l (sp)+,d0/d1-d2/a5
  1695.     addq.l #1,d0
  1696.     addq.l #1,d7
  1697.     rts
  1698.  
  1699. fg_2byte_2:
  1700.     movem.l d0/d1-d2/a5,-(sp)
  1701.  
  1702.     bclr.l #1,d3    * アンダーラインフラグのチェック(破壊検査)
  1703.     beq fg_2byte_2_skip
  1704.  
  1705.     move.l a6,d0    * dn があるか？
  1706.     beq fg_2byte_2_skip
  1707.  
  1708.     move.b #$ff,0(a6,d7)
  1709.     move.b #$ff,1(a6,d7)
  1710.  
  1711. fg_2byte_2_skip:
  1712.     btst.b #3,_CTCOLOR
  1713.     bne fg_2byte_2_rev
  1714.  
  1715.     lea 0(a5,d7),a5
  1716.     moveq.l #8,d2
  1717.     moveq.l    #$16,d0    *FNTADR
  1718.     trap #15
  1719.     move.l d0,a2
  1720.  
  1721.     move.l a5,d0
  1722.     btst.l #0,d0
  1723.     bne odd_loop1
  1724.     btst.l #0,d6
  1725.     bne odd_loop1
  1726.  
  1727. * even !
  1728.     move.w (a2)+,(a5)
  1729.     adda.w d6,a5
  1730.     move.w (a2)+,(a5)
  1731.     adda.w d6,a5
  1732.     move.w (a2)+,(a5)
  1733.     adda.w d6,a5
  1734.     move.w (a2)+,(a5)
  1735.     adda.w d6,a5
  1736.     move.w (a2)+,(a5)
  1737.     adda.w d6,a5
  1738.     move.w (a2)+,(a5)
  1739.     adda.w d6,a5
  1740.     move.w (a2)+,(a5)
  1741.     adda.w d6,a5
  1742.     move.w (a2)+,(a5)
  1743.     adda.w d6,a5
  1744.     move.w (a2)+,(a5)
  1745.     adda.w d6,a5
  1746.     move.w (a2)+,(a5)
  1747.     adda.w d6,a5
  1748.     move.w (a2)+,(a5)
  1749.     adda.w d6,a5
  1750.     move.w (a2)+,(a5)
  1751.     adda.w d6,a5
  1752.     move.w (a2)+,(a5)
  1753.     adda.w d6,a5
  1754.     move.w (a2)+,(a5)
  1755.     adda.w d6,a5
  1756.     move.w (a2)+,(a5)
  1757.     adda.w d6,a5
  1758.     move.w (a2)+,(a5)
  1759.     adda.w d6,a5
  1760.  
  1761.     movem.l (sp)+,d0/d1-d2/a5
  1762.     addq.l #2,d0
  1763.     addq.l #2,d7
  1764.     rts
  1765.  
  1766. odd_loop1:
  1767.     subq.l #1,d6        * 全角だから
  1768.  
  1769.     move.b (a2)+,(a5)+
  1770.     move.b (a2)+,(a5)
  1771.     adda.w d6,a5
  1772.     move.b (a2)+,(a5)+
  1773.     move.b (a2)+,(a5)
  1774.     adda.w d6,a5
  1775.     move.b (a2)+,(a5)+
  1776.     move.b (a2)+,(a5)
  1777.     adda.w d6,a5
  1778.     move.b (a2)+,(a5)+
  1779.     move.b (a2)+,(a5)
  1780.     adda.w d6,a5
  1781.     move.b (a2)+,(a5)+
  1782.     move.b (a2)+,(a5)
  1783.     adda.w d6,a5
  1784.     move.b (a2)+,(a5)+
  1785.     move.b (a2)+,(a5)
  1786.     adda.w d6,a5
  1787.     move.b (a2)+,(a5)+
  1788.     move.b (a2)+,(a5)
  1789.     adda.w d6,a5
  1790.     move.b (a2)+,(a5)+
  1791.     move.b (a2)+,(a5)
  1792.     adda.w d6,a5
  1793.     move.b (a2)+,(a5)+
  1794.     move.b (a2)+,(a5)
  1795.     adda.w d6,a5
  1796.     move.b (a2)+,(a5)+
  1797.     move.b (a2)+,(a5)
  1798.     adda.w d6,a5
  1799.     move.b (a2)+,(a5)+
  1800.     move.b (a2)+,(a5)
  1801.     adda.w d6,a5
  1802.     move.b (a2)+,(a5)+
  1803.     move.b (a2)+,(a5)
  1804.     adda.w d6,a5
  1805.     move.b (a2)+,(a5)+
  1806.     move.b (a2)+,(a5)
  1807.     adda.w d6,a5
  1808.     move.b (a2)+,(a5)+
  1809.     move.b (a2)+,(a5)
  1810.     adda.w d6,a5
  1811.     move.b (a2)+,(a5)+
  1812.     move.b (a2)+,(a5)
  1813.     adda.w d6,a5
  1814.     move.b (a2)+,(a5)+
  1815.     move.b (a2)+,(a5)
  1816.     adda.w d6,a5
  1817.  
  1818.     addq.l #1,d6        * 戻す
  1819.     movem.l (sp)+,d0/d1-d2/a5
  1820.     addq.l #2,d0
  1821.     addq.l #2,d7
  1822.     rts
  1823.  
  1824. fg_2byte_2_rev
  1825.  
  1826.     lea 0(a5,d7),a5
  1827.     moveq.l #8,d2
  1828.     moveq.l    #$16,d0    *FNTADR
  1829.     trap #15
  1830.     move.l d0,a2
  1831.  
  1832.     moveq.l #-1,d2
  1833.  
  1834.     move.l a5,d0
  1835.     btst.l #0,d0
  1836.     bne odd_loop2
  1837.     btst.l #0,d6
  1838.     bne odd_loop2
  1839.  
  1840. * even !
  1841.     move.w (a2)+,d1
  1842.     eor.w d2,d1
  1843.     move.w d1,(a5)
  1844.     adda.w d6,a5
  1845.     move.w (a2)+,d1
  1846.     eor.w d2,d1
  1847.     move.w d1,(a5)
  1848.     adda.w d6,a5
  1849.     move.w (a2)+,d1
  1850.     eor.w d2,d1
  1851.     move.w d1,(a5)
  1852.     adda.w d6,a5
  1853.     move.w (a2)+,d1
  1854.     eor.w d2,d1
  1855.     move.w d1,(a5)
  1856.     adda.w d6,a5
  1857.     move.w (a2)+,d1
  1858.     eor.w d2,d1
  1859.     move.w d1,(a5)
  1860.     adda.w d6,a5
  1861.     move.w (a2)+,d1
  1862.     eor.w d2,d1
  1863.     move.w d1,(a5)
  1864.     adda.w d6,a5
  1865.     move.w (a2)+,d1
  1866.     eor.w d2,d1
  1867.     move.w d1,(a5)
  1868.     adda.w d6,a5
  1869.     move.w (a2)+,d1
  1870.     eor.w d2,d1
  1871.     move.w d1,(a5)
  1872.     adda.w d6,a5
  1873.     move.w (a2)+,d1
  1874.     eor.w d2,d1
  1875.     move.w d1,(a5)
  1876.     adda.w d6,a5
  1877.     move.w (a2)+,d1
  1878.     eor.w d2,d1
  1879.     move.w d1,(a5)
  1880.     adda.w d6,a5
  1881.     move.w (a2)+,d1
  1882.     eor.w d2,d1
  1883.     move.w d1,(a5)
  1884.     adda.w d6,a5
  1885.     move.w (a2)+,d1
  1886.     eor.w d2,d1
  1887.     move.w d1,(a5)
  1888.     adda.w d6,a5
  1889.     move.w (a2)+,d1
  1890.     eor.w d2,d1
  1891.     move.w d1,(a5)
  1892.     adda.w d6,a5
  1893.     move.w (a2)+,d1
  1894.     eor.w d2,d1
  1895.     move.w d1,(a5)
  1896.     adda.w d6,a5
  1897.     move.w (a2)+,d1
  1898.     eor.w d2,d1
  1899.     move.w d1,(a5)
  1900.     adda.w d6,a5
  1901.     move.w (a2)+,d1
  1902.     eor.w d2,d1
  1903.     move.w d1,(a5)
  1904.     adda.w d6,a5
  1905.  
  1906.     movem.l (sp)+,d0/d1-d2/a5
  1907.     addq.l #2,d0
  1908.     addq.l #2,d7
  1909.     rts
  1910.  
  1911. odd_loop2:
  1912.     move.w (a2)+,d1
  1913.     eor.w d2,d1
  1914.     move.b d1,1(a5)
  1915.     lsr.w #8,d1
  1916.     move.b d1,(a5)
  1917.     adda.w d6,a5
  1918.  
  1919.     move.w (a2)+,d1
  1920.     eor.w d2,d1
  1921.     move.b d1,1(a5)
  1922.     lsr.w #8,d1
  1923.     move.b d1,(a5)
  1924.     adda.w d6,a5
  1925.  
  1926.     move.w (a2)+,d1
  1927.     eor.w d2,d1
  1928.     move.b d1,1(a5)
  1929.     lsr.w #8,d1
  1930.     move.b d1,(a5)
  1931.     adda.w d6,a5
  1932.     move.w (a2)+,d1
  1933.     eor.w d2,d1
  1934.     move.b d1,1(a5)
  1935.     lsr.w #8,d1
  1936.     move.b d1,(a5)
  1937.     adda.w d6,a5
  1938.     move.w (a2)+,d1
  1939.     eor.w d2,d1
  1940.     move.b d1,1(a5)
  1941.     lsr.w #8,d1
  1942.     move.b d1,(a5)
  1943.     adda.w d6,a5
  1944.     move.w (a2)+,d1
  1945.     eor.w d2,d1
  1946.     move.b d1,1(a5)
  1947.     lsr.w #8,d1
  1948.     move.b d1,(a5)
  1949.     adda.w d6,a5
  1950.     move.w (a2)+,d1
  1951.     eor.w d2,d1
  1952.     move.b d1,1(a5)
  1953.     lsr.w #8,d1
  1954.     move.b d1,(a5)
  1955.     adda.w d6,a5
  1956.     move.w (a2)+,d1
  1957.     eor.w d2,d1
  1958.     move.b d1,1(a5)
  1959.     lsr.w #8,d1
  1960.     move.b d1,(a5)
  1961.     adda.w d6,a5
  1962.     move.w (a2)+,d1
  1963.     eor.w d2,d1
  1964.     move.b d1,1(a5)
  1965.     lsr.w #8,d1
  1966.     move.b d1,(a5)
  1967.     adda.w d6,a5
  1968.     move.w (a2)+,d1
  1969.     eor.w d2,d1
  1970.     move.b d1,1(a5)
  1971.     lsr.w #8,d1
  1972.     move.b d1,(a5)
  1973.     adda.w d6,a5
  1974.     move.w (a2)+,d1
  1975.     eor.w d2,d1
  1976.     move.b d1,1(a5)
  1977.     lsr.w #8,d1
  1978.     move.b d1,(a5)
  1979.     adda.w d6,a5
  1980.     move.w (a2)+,d1
  1981.     eor.w d2,d1
  1982.     move.b d1,1(a5)
  1983.     lsr.w #8,d1
  1984.     move.b d1,(a5)
  1985.     adda.w d6,a5
  1986.     move.w (a2)+,d1
  1987.     eor.w d2,d1
  1988.     move.b d1,1(a5)
  1989.     lsr.w #8,d1
  1990.     move.b d1,(a5)
  1991.     adda.w d6,a5
  1992.     move.w (a2)+,d1
  1993.     eor.w d2,d1
  1994.     move.b d1,1(a5)
  1995.     lsr.w #8,d1
  1996.     move.b d1,(a5)
  1997.     adda.w d6,a5
  1998.     move.w (a2)+,d1
  1999.     eor.w d2,d1
  2000.     move.b d1,1(a5)
  2001.     lsr.w #8,d1
  2002.     move.b d1,(a5)
  2003.     adda.w d6,a5
  2004.     move.w (a2)+,d1
  2005.     eor.w d2,d1
  2006.     move.b d1,1(a5)
  2007.     lsr.w #8,d1
  2008.     move.b d1,(a5)
  2009.     adda.w d6,a5
  2010.  
  2011.     movem.l (sp)+,d0/d1-d2/a5
  2012.     addq.l #2,d0
  2013.     addq.l #2,d7
  2014.     rts
  2015.  
  2016. fg_2byte_rb_r:
  2017.     movem.l d0/d1-d2/a4,-(sp)
  2018.     lea 1(a4,d7),a4
  2019.     bra fg_2byte_rb_l0
  2020.  
  2021. fg_2byte_rb_l:
  2022. *    btst.b #3,_CTCOLOR
  2023. *    bne fg_1byte_1_rev
  2024.  
  2025.  
  2026.     movem.l d0/d1-d2/a4,-(sp)
  2027.     lea 0(a4,d7),a4
  2028.  
  2029. fg_2byte_rb_l0:
  2030.     moveq.l #8,d2
  2031.     moveq.l    #$16,d0    * FNTADR
  2032.     trap #15
  2033.     move.l d0,a2
  2034.  
  2035.     move.b (a2)+,(a4)
  2036.     adda.w d6,a4
  2037.     move.b (a2)+,(a4)
  2038.     adda.w d6,a4
  2039.     move.b (a2)+,(a4)
  2040.     adda.w d6,a4
  2041.     move.b (a2)+,(a4)
  2042.     adda.w d6,a4
  2043.     move.b (a2)+,(a4)
  2044.     adda.w d6,a4
  2045.     move.b (a2)+,(a4)
  2046.     adda.w d6,a4
  2047.     move.b (a2)+,(a4)
  2048.     adda.w d6,a4
  2049.     move.b (a2)+,(a4)
  2050.     adda.w d6,a4
  2051.  
  2052.     movem.l (sp)+,d0/d1-d2/a4
  2053.     rts
  2054.  
  2055. fg_2byte_rb_2center:
  2056. *    btst.b #3,_CTCOLOR
  2057. *    bne fg_1byte_1_rev
  2058.  
  2059.     movem.l d0-d2/a4-a5,-(sp)
  2060.     lea 0(a4,d7),a4
  2061.  
  2062.     moveq.l #8,d2
  2063.     moveq.l    #$16,d0    * FNTADR
  2064.     trap #15
  2065.     move.l d0,a2
  2066.  
  2067.     move.b (a2)+,d1    * get data
  2068.     move.b d1,d2
  2069.     lsr.b #4,d1
  2070.     lsl.b #4,d2
  2071.     move.b d1,(a4)
  2072.     move.b d2,1(a4)
  2073.     adda.w d6,a4
  2074.  
  2075.     move.b (a2)+,d1    * get data
  2076.     ror.b #4,d1
  2077.     move.b d1,d2
  2078.     andi.b #$0f,d1
  2079.     andi.b #$f0,d2
  2080.     move.b d1,(a4)
  2081.     move.b d2,1(a4)
  2082.     adda.w d6,a4
  2083.  
  2084.     move.b (a2)+,d1    * get data
  2085.     ror.b #4,d1
  2086.     move.b d1,d2
  2087.     andi.b #$0f,d1
  2088.     andi.b #$f0,d2
  2089.     move.b d1,(a4)
  2090.     move.b d2,1(a4)
  2091.     adda.w d6,a4
  2092.  
  2093.     move.b (a2)+,d1    * get data
  2094.     ror.b #4,d1
  2095.     move.b d1,d2
  2096.     andi.b #$0f,d1
  2097.     andi.b #$f0,d2
  2098.     move.b d1,(a4)
  2099.     move.b d2,1(a4)
  2100.     adda.w d6,a4
  2101.  
  2102.     move.b (a2)+,d1    * get data
  2103.     ror.b #4,d1
  2104.     move.b d1,d2
  2105.     andi.b #$0f,d1
  2106.     andi.b #$f0,d2
  2107.     move.b d1,(a4)
  2108.     move.b d2,1(a4)
  2109.     adda.w d6,a4
  2110.  
  2111.     move.b (a2)+,d1    * get data
  2112.     ror.b #4,d1
  2113.     move.b d1,d2
  2114.     andi.b #$0f,d1
  2115.     andi.b #$f0,d2
  2116.     move.b d1,(a4)
  2117.     move.b d2,1(a4)
  2118.     adda.w d6,a4
  2119.  
  2120.     move.b (a2)+,d1    * get data
  2121.     ror.b #4,d1
  2122.     move.b d1,d2
  2123.     andi.b #$0f,d1
  2124.     andi.b #$f0,d2
  2125.     move.b d1,(a4)
  2126.     move.b d2,1(a4)
  2127.     adda.w d6,a4
  2128.  
  2129.     move.b (a2)+,d1    * get data
  2130.     ror.b #4,d1
  2131.     move.b d1,d2
  2132.     andi.b #$0f,d1
  2133.     andi.b #$f0,d2
  2134.     move.b d1,(a4)
  2135.     move.b d2,1(a4)
  2136.     adda.w d6,a4
  2137.  
  2138.     movem.l (sp)+,d0-d2/a4-a5
  2139.     rts
  2140.  
  2141.     .data
  2142.     .even
  2143. fg_work
  2144.     ds.b    2+2+16*2
  2145.     .even
  2146. sdl_save
  2147.     ds.l    14
  2148. save_ssp
  2149.     ds.l    1
  2150.     .even
  2151. #endasm
  2152. }
  2153.  
  2154. /* パターンを表示する */
  2155. /* 新しい x 座標を返す */
  2156. /* 実際はバイト単位で処理する */
  2157. void
  2158. etc_put_pattern(int x,int yd,UBYTE *pat,STR blue_mask)
  2159. {
  2160.     register int c;
  2161.  
  2162.     c = *((UWORD *) PAT0) = *((UWORD *) PAT) /= 8;
  2163.     ((UWORD *) PAT0)[1] = ((UWORD *) PAT)[1];
  2164.  
  2165.     if (CTCOLOR & 1) {
  2166.         etc_textput(x,yd,PAT);
  2167.     } else {
  2168.         etc_textput(x,yd,PAT0);
  2169.     }
  2170.  
  2171.     if (CTCOLOR & 2) {
  2172.         etc_mask_blue(PAT,blue_mask);
  2173.         etc_textput(x,yd+1024,PAT);
  2174.     } else {
  2175.         etc_textput(x,yd+1024,PAT0);
  2176.     }
  2177. }
  2178.  
  2179. #if 1
  2180. /* p = xsize.w, ysize.w, data... */
  2181. void
  2182. etc_textput(int x,int y,UBYTE *p)
  2183. {
  2184. #asm
  2185.     movem.l d1/d2/d3/a1/a2,-(sp)
  2186.  
  2187.     move.l 32(sp),a2    *p
  2188.     move.l 28(sp),d0    *y
  2189.     move.l 24(sp),d1    *x
  2190.  
  2191.     move.w (a2)+,d3        *xs
  2192.     moveq.l #0,d2
  2193.     move.w (a2)+,d2        *ys:個数
  2194. *転送先アドレスＯＫ
  2195.  
  2196.     asl.l #7,d0        *y=y*128
  2197.     add.l d0,d1        *d1=y*128+x
  2198.     add.l #$e00000,d1    *d1=0xe00000+y*128+x
  2199.  
  2200.     lea et_dba_rb,a0    *DMA table
  2201.     move.l a0,a1
  2202.     move.l d2,d0
  2203.     subq.l #1,d0
  2204. et_loop:
  2205.     move.l d1,(a0)+
  2206.     move.w d3,(a0)+
  2207.     add.l #128,d1
  2208.     dbra d0,et_loop
  2209.     
  2210. *    for(j=y*128+x,i=0;i<ys;i++,j+=128) {
  2211. *        TB[i].adr = 0xe00000+j;
  2212. *        TB[i].len = xs;
  2213. *    }
  2214.  
  2215.     move.b #$85,d1        *mode 0b1000 0101
  2216.     moveq.l #$8b,d0        *DMAMOV_A
  2217.     trap #15        *iocs call
  2218.     movem.l (sp)+,d1/d2/d3/a1/a2
  2219.     rts
  2220.  
  2221.     .data
  2222.     .even
  2223. et_dba_rb:
  2224.     ds.b    6*142        *最大１４２ブロック
  2225. #endasm
  2226. }
  2227. #else
  2228. struct    CHAIN    {
  2229.     INT    adr;
  2230.     UWORD    len;
  2231. };
  2232. /* p = xsize.w, ysize.w, data... */
  2233. void
  2234. etc_textput(int x,int y,UBYTE *p)
  2235. {
  2236.     register UWORD xs,ys;
  2237.     register int i,j;
  2238.     struct CHAIN TB[28];    /* max 28 */
  2239.  
  2240.     xs = *((UWORD *) p);
  2241.     ys = ((UWORD *) p)[1];
  2242.     p += 4;
  2243.  
  2244.     for(j=y*128+x,i=0;i<ys;i++,j+=128) {
  2245.         TB[i].adr = 0xe00000+j;
  2246.         TB[i].len = xs;
  2247.     }
  2248.     DMAMOV_A(&TB,p,0b10000101,ys);
  2249. }
  2250.  
  2251. /* p = xsize.w, ysize.w, data... */
  2252. void
  2253. etc_textput(int x,int y,UBYTE *p)
  2254. {
  2255.     register UWORD xs,ys;
  2256.     register int i,j;
  2257.  
  2258.     xs = *((UWORD *) p);
  2259.     ys = ((UWORD *) p)[1];
  2260.     p += 4;
  2261.  
  2262.     for(j=y*128+x,i=0;i<ys;i++,j+=128) {
  2263.         DMAMOVE(p,0xe00000+j,0b00000101,xs);
  2264.         p += xs;
  2265.     }
  2266. }
  2267.  
  2268.  
  2269. void
  2270. etc_textput(int x,int y,UBYTE *p)
  2271. {
  2272. #asm
  2273.     movem.l    d0-d4/a0-a3,tp_save
  2274.  
  2275.     moveq.l    #$81,d0        * to super
  2276.     clr.l    a1
  2277.     trap    #15
  2278.     move.l    d0,tp_save_ssp
  2279.  
  2280.     move.l 8(sp),d1        *y
  2281.     move.l 12(sp),a1    *pattern data
  2282.     move.w (a1)+,d2        *x byte
  2283.     move.w (a1)+,d3        *y line
  2284.     move.l 4(sp),d0        *x
  2285.     bne not_from_0
  2286.     cmpi.w #96,d2
  2287.     bne not_from_0
  2288.  
  2289. *address = $E00000+d0+(d1*128)
  2290.     add.l #$e00000,d0
  2291.     asl.l #7,d1
  2292.     add.l d1,d0
  2293.     movea.l d0,a2
  2294.  
  2295.     subq.l #1,d3
  2296. loopy_96:
  2297.     move.l a2,a3
  2298. *+++++++
  2299.     move.l (a1)+,(a3)+
  2300.     move.l (a1)+,(a3)+
  2301.     move.l (a1)+,(a3)+
  2302.     move.l (a1)+,(a3)+
  2303.     move.l (a1)+,(a3)+
  2304.     move.l (a1)+,(a3)+
  2305.     move.l (a1)+,(a3)+
  2306.     move.l (a1)+,(a3)+
  2307.     move.l (a1)+,(a3)+
  2308.     move.l (a1)+,(a3)+
  2309.     move.l (a1)+,(a3)+
  2310.     move.l (a1)+,(a3)+
  2311.     move.l (a1)+,(a3)+
  2312.     move.l (a1)+,(a3)+
  2313.     move.l (a1)+,(a3)+
  2314.     move.l (a1)+,(a3)+
  2315.     move.l (a1)+,(a3)+
  2316.     move.l (a1)+,(a3)+
  2317.     move.l (a1)+,(a3)+
  2318.     move.l (a1)+,(a3)+
  2319.     move.l (a1)+,(a3)+
  2320.     move.l (a1)+,(a3)+
  2321.     move.l (a1)+,(a3)+
  2322.     move.l (a1)+,(a3)+
  2323. *+++++++
  2324.     adda.w #128,a2    * 1 line down
  2325.     dbra d3,loopy_96
  2326.  
  2327.     bra finis
  2328.  
  2329. *d0=x, d2=xbyte
  2330. *(d0+d2) > 96 -> d2=96-d0
  2331.  
  2332. not_from_0:
  2333.  
  2334.     move.l d0,d4
  2335.     add.l d2,d4
  2336.     cmpi.l #96,d4
  2337.     ble not_from_00
  2338. *越えた
  2339. *address = $E00000+d0+(d1*128)
  2340.     moveq.l #95,d4
  2341.     sub.l d0,d4    *d4 = 96 - d0 - 1
  2342.     add.l #$e00000,d0
  2343.     asl.l #7,d1
  2344.     add.l d1,d0
  2345.     move.l d0,a2    *first address
  2346.  
  2347.     subq.l #1,d3    *ybyte dec
  2348. loopy:
  2349.     move.l d4,d0
  2350.     move.l a2,a3    *copy dest
  2351.     move.l a1,a0    *copy source
  2352. loopx:
  2353.     move.b (a0)+,(a3)+
  2354.     dbra d0,loopx
  2355.     adda.w #128,a2    * 1 line down
  2356.     adda.w d2,a1    * inc source
  2357.     dbra d3,loopy
  2358.     bra finis
  2359.  
  2360. not_from_00:
  2361. *address = $E00000+d0+(d1*128)
  2362.     add.l #$e00000,d0
  2363.     asl.l #7,d1
  2364.     add.l d1,d0
  2365.     movea.l d0,a2
  2366.  
  2367.     subq.l #1,d3
  2368.     subq.l #1,d2
  2369. loopy0:
  2370.     move.l d2,d4
  2371.     move.l a2,a3
  2372. loopx0:
  2373.     move.b (a1)+,(a3)+
  2374.     dbra d4,loopx0
  2375.     adda.w #128,a2    * 1 line down
  2376.     dbra d3,loopy0
  2377.  
  2378. finis:
  2379.     moveq.l    #$81,d0
  2380.     movea.l    tp_save_ssp,a1
  2381.     trap    #15
  2382.  
  2383.     movem.l    tp_save,d0-d4/a0-a3
  2384.     rts
  2385.  
  2386.     .even
  2387.     .data
  2388. tp_save:
  2389.     ds.l    16
  2390.     .even
  2391. tp_save_ssp:
  2392.     ds.l    1
  2393. #endasm
  2394. }
  2395.  
  2396.  
  2397. #endif
  2398.  
  2399.  
  2400. void
  2401. etc_mask_blue(STR pat,STR bm)
  2402. {
  2403. #asm
  2404. *    register int i,x,x0;
  2405. *    register STR p;
  2406.  
  2407.     movem.l d1/d3/d4/a3/a4/a5,-(sp)
  2408.     move.l 28(sp),a4    *pat
  2409.     move.l 32(sp),a3    *bm
  2410.     beq emb_finis
  2411. *    if (bm) {    /* 指定されたなら */
  2412.     move.w _LYW_MAIN,d1
  2413.     subq.l #1,d1    *d1 = _LYW_MAIN-1
  2414.  
  2415.     moveq.l #0,d3
  2416.     move.w (a4),d3
  2417.     move.l d3,d4    *d3=x,d4=x0
  2418. *        x0 = x = *((UWORD *) pat);    /* 横のバイト数 */
  2419.     move.w _LYW_UPPER,d0
  2420.     mulu.w d3,d0
  2421.     lea 4(a4,d0),a4
  2422. *        p = pat + 4 + (LYW_UPPER*x);
  2423.     subq.l #1,d3
  2424.     ble emb_finis
  2425. emb_loop1:
  2426.     tst.b (a3)+
  2427.     bne emb_skip
  2428. *        while(--x >= 0) {
  2429. *            if (!bm[x]) {        /* 青くする */
  2430.     move.l a4,a5    *save
  2431.     move.l d1,d0    *d1 = _LYW_MAIN-1
  2432. emb_loop2:
  2433.     clr.b (a4)
  2434.     adda.l d4,a4
  2435.     dbra d0,emb_loop2
  2436.     move.l a5,a4    *back
  2437. *                for(i=0;i<LYW_MAIN;i++) {
  2438. *                    p[x+i*x0] = EOS;
  2439. *                }
  2440. *            }
  2441. *        }
  2442. *    }
  2443. emb_skip:
  2444.     addq.l #1,a4
  2445.     dbra d3,emb_loop1
  2446. emb_finis:
  2447.     movem.l (sp)+,d1/d3/d4/a3/a4/a5
  2448.     rts
  2449. #endasm
  2450. }
  2451.  
  2452. /* ファイル名に使える文字かどうかを調べる */
  2453. /* バックスラッシュとドットもＯＫ */
  2454. int
  2455. etc_is_filename_char(UWORD c)
  2456. {
  2457.             /* v-英数字、アンダーライン */
  2458.     return((c > 0x80) || iscsym(c) || strchr("&#()@^{}!.\\",c));
  2459. }
  2460.  
  2461. STR
  2462. etc_first_filename_char(STR s)
  2463. {
  2464.     register UWORD c;
  2465.  
  2466.     while(c = etc_jfirst(s)) {
  2467.         if (etc_is_filename_char(c)) {
  2468. /*
  2469. if (c == ' ') {
  2470. error("get space");
  2471. }
  2472. */
  2473.             return(s);
  2474.         }
  2475.         if (c >= 0x100) {
  2476.             s += 2;
  2477.         } else {
  2478.             s++;
  2479.         }
  2480.     }
  2481.     return(NULL);
  2482. }
  2483.  
  2484. /* 長すぎるかどうかを返す */
  2485. int
  2486. etc_limit_strcat(STR d,STR s,int limit)
  2487. {
  2488.     if ((strlen(d) + strlen(s)) > limit) {
  2489.         return(1);
  2490.     }
  2491.     strcat(d,s);
  2492.     return(0);
  2493. }
  2494.  
  2495. /* 見付けたらコードの次のアドレスを返す */
  2496. int
  2497. etc_get_left(STR s,UBYTE code,STR d)
  2498. {
  2499.     register STR p;
  2500.  
  2501.     if (p = strchr(s,code)) {
  2502.         strncpy(d,s,p-s);
  2503.         d[(p++)-s] = EOS;    /* get left */
  2504.     }
  2505.     return(p);
  2506. }
  2507.  
  2508. int
  2509. etc_child(STR task)
  2510. {
  2511.     return(child(task));
  2512. }
  2513.  
  2514. /* デレイなウエイト */
  2515. void
  2516. etc_while_fep_qxf()
  2517. {
  2518.     register UINT w;
  2519.     register int t0,t;
  2520.     t0 = ONTIME();
  2521.  
  2522.     while((w = fep_qxf()) && (w != 0x210)) {    /* マウスの左ボタンでない限り */
  2523.         if ((t = ONTIME()) < t0) {    /* リセットされた */
  2524.             t += 8640000;
  2525.         }
  2526.         if ((t - t0) >= 20) {
  2527.             break;
  2528.         }
  2529.     }
  2530. }
  2531.  
  2532. #if 1
  2533.  
  2534. void
  2535. etc_beep()
  2536. {
  2537.     beep();
  2538. }
  2539.  
  2540. #else
  2541.  
  2542. void
  2543. etc_beep()
  2544. {
  2545.     int t0,t;
  2546.     int p0,p3;
  2547.  
  2548.     p0 = TPALET(0,-1);
  2549.     p3 = TPALET(3,-1);
  2550.     TPALET(0,p3);
  2551.     TPALET(3,p0);    /* 反転 */
  2552.     t0 = ONTIME();
  2553.     beep();
  2554.     while(1) {
  2555.         t = ONTIME();
  2556.         if ((t < t0) || (t > (t0+5))) {
  2557.             break;
  2558.         }
  2559.     }
  2560.     TPALET(0,p0);
  2561.     TPALET(3,p3);
  2562. }
  2563.  
  2564. #endif
  2565.  
  2566. #if 0
  2567.  
  2568. void
  2569. etc_www()
  2570. {
  2571.     while(!fep_shift_ctrl());
  2572. }
  2573.  
  2574. void
  2575. etc_www0()
  2576. {
  2577.     while(!fep_shift_ctrl());
  2578.     while(fep_shift_ctrl());
  2579. }
  2580.  
  2581. #endif
  2582.  
  2583. extern COMMAND_UNIT command_table[MAX_COMMAND_NUMBER];
  2584. extern COMMAND_UNIT command_table0[MAX_COMMAND_NUMBER];        /* ME */
  2585. extern COMMAND_UNIT command_table1[MAX_COMMAND_NUMBER];        /* ED */
  2586. extern COMMAND_UNIT command_table00[MAX_COMMAND_NUMBER];    /* ME */
  2587. extern COMMAND_UNIT command_table10[MAX_COMMAND_NUMBER];    /* ED */
  2588.  
  2589. /* キーバインドを CMDMOD にもとづいて書き換える */
  2590. /* キーバインドが汚れていれば何もしない */
  2591. /* キーバインドを汚す */
  2592. /* 該当番号を返す */
  2593. /* 該当しなかった場合は -1 を返す */
  2594. int
  2595. etc_kb_change(UWORD ks[],UWORD kd[])
  2596. {
  2597.     register int i,j;
  2598.     register UWORD *p;
  2599.  
  2600.     for(i=0;i<MAX_COMMAND_NUMBER;i++) {
  2601.         if (CMDMOD) {    /* ed である */
  2602.             p = command_table1[i].COMMAND_STRING;
  2603.         } else {    /* me である */
  2604.             p = command_table0[i].COMMAND_STRING;
  2605.         }
  2606. /*printf("(%d)(%d)\n",i,etc_uwordcmp(p,ks));binkey();*/
  2607.         if ((!p[MAX_COMMAND_STROKE]) && etc_uwordcmp(p,ks)) {
  2608.                 /* 汚れてない＆一致した */
  2609.             for(j=0;j<MAX_COMMAND_STROKE;j++) {
  2610.                 p[j] = kd[j];    /* 転送する */
  2611.             }
  2612.             etc_kb_soil(i);    /* 汚す */
  2613.             return(i);
  2614.         }
  2615.     }
  2616.     /* 一致するものがなかった */
  2617.     return(-1);
  2618. }
  2619.  
  2620. int
  2621. etc_uwordcmp(UWORD *s,UWORD *d)
  2622. {
  2623.     while(*s && *d) {    /* どちらも０でない限り */
  2624.         if (*s++ != *d++) {
  2625.             return(0);
  2626.         }
  2627.     }
  2628.     return(*s == *d);    /* 共に０か？ */
  2629. }
  2630.  
  2631. /* キーバインドを汚す */
  2632. void
  2633. etc_kb_soil(int i)
  2634. {
  2635.     if (CMDMOD) {
  2636.         command_table1[i].COMMAND_STRING[MAX_COMMAND_STROKE+1-1] = (UWORD)0xffff;    /* UWORD! */
  2637.     } else {
  2638.         command_table0[i].COMMAND_STRING[MAX_COMMAND_STROKE+1-1] = (UWORD)0xffff;    /* UWORD! */
  2639.     }
  2640. }
  2641.  
  2642. /* キーバインドをすべて洗う */
  2643. void
  2644. etc_kb_wash()
  2645. {
  2646.     register int i;
  2647.  
  2648.     for(i=0;i<MAX_COMMAND_NUMBER;i++) {
  2649.         command_table0[i].COMMAND_STRING[MAX_COMMAND_STROKE+1-1] = 0x0000;    /* UWORD! */
  2650.         command_table1[i].COMMAND_STRING[MAX_COMMAND_STROKE+1-1] = 0x0000;    /* UWORD! */
  2651.     }
  2652. }
  2653.  
  2654. void
  2655. etc_wait_y()
  2656. {
  2657.     UBYTE c;
  2658.  
  2659.     fep_key_clear();
  2660.     while(1) {
  2661.         etc_beep();
  2662.         c = toupper(fep_inkey_raw());
  2663.         if (c == 'Y') {
  2664.             break;
  2665.         }
  2666.     }
  2667. }
  2668.  
  2669. UBYTE
  2670. etc_command_pick(UBYTE c,void    (*f)())
  2671. {
  2672.     register int i,c0;
  2673.  
  2674.     for(i=0;i<MAX_COMMAND_NUMBER;i++) {
  2675.         if (command_table[i].FUNCTION == f) {    /* 関数が一致 */
  2676.             if (!command_table[i].COMMAND_STRING[1]) {    /* １ストロークだ */
  2677.                 c0 = command_table[i].COMMAND_STRING[0];
  2678.                 if (c0 < 0x20) {
  2679.                     c = c0;
  2680.                 } else {    /* コントロールキーではない！ */
  2681.                     c |= 0x80;    /* MSB を立てる */
  2682.                 }
  2683.             } else {    /* １ストロークではない！ */
  2684.                 c |= 0x80;    /* MSB を立てる */
  2685.             }
  2686.             break;
  2687.         }
  2688.     }
  2689.     return(c);
  2690. }
  2691.  
  2692. void
  2693. etc_command_patch_miss(STR mes,UBYTE code)
  2694. {
  2695.     UBYTE w[MAXLINE];
  2696.  
  2697.     sprintf(w,"%sのコードを ^%c にします。",mes,code+'@');
  2698.     error(w);
  2699. }
  2700.  
  2701. int
  2702. etc_remove_cr_tab(STR s)
  2703. {
  2704.     register int i,j;
  2705.  
  2706.     for(i=j=0;s[i];) {
  2707.         if ((s[i] == TAB) || (s[i] == CR)) {
  2708.             i++;
  2709.         } else {
  2710.             s[j++] = s[i++];
  2711.         }
  2712.     }
  2713.     s[j] = EOS;
  2714.     return(j);
  2715. }
  2716.  
  2717. int
  2718. etc_jiskata(UINT c)
  2719. {
  2720.     if (jiskata(c)) {
  2721.         return(1);
  2722.     } else if ((0xa0 <= c) && (c <= 0xdf)) {    /* １バイト半角カタカナだ */
  2723.         return(1);
  2724.     } else if ((0xf0a0 <= c) && (c <= 0xf0df)) {    /* １／４角上付カタカナ */
  2725.         return(1);
  2726.     } else if ((0xf2a0 <= c) && (c <= 0xf2df)) {    /* １／４角下付カタカナ */
  2727.         return(1);
  2728.     }
  2729.     
  2730.     return(0);
  2731. }
  2732.  
  2733. int
  2734. etc_jishira(UINT c)
  2735. {
  2736.     if (jishira(c)) {
  2737.         return(1);
  2738.     }
  2739.     /* ２バイト半角文字かも知れない */
  2740.     if ((0x8086 <= c) && (c <= 0x80fd)) {
  2741.         return(1);
  2742.     }
  2743.     if (((0xf086 <= c) && (c <= 0xf3fd)) && ((c & 0xff) >= 0x86) && !etc_jiskata(c)) {
  2744.         return(1);    /* 上付か下付のひらがな */
  2745.     }
  2746.     return(0);
  2747. }
  2748.  
  2749. /* 全角のカタカナを、全角のひらがなにする */
  2750. /* 半角のカタカナも２バイト半角文字のひらがなにする */
  2751. /* １／４角も面倒みる */
  2752. void
  2753. etc_zen_kata_to_hira(STR d0,STR s,int size)
  2754. {
  2755.     UINT c;
  2756.     UBYTE dd[VERY_LONG_LINE];
  2757.     register UBYTE *d;
  2758.  
  2759.     d = dd;
  2760.     while(s = etc_jfirst_x(s,&c)) {
  2761.         c = etc_zen_kata_to_hira1(c);
  2762.         if (c > 0xff) {    /* ２バイト文字だ */
  2763.             *d++ = (c >> 8);
  2764.             *d++ = c &0xff;
  2765.         } else {
  2766.             *d++ = c;
  2767.         }
  2768.     }
  2769.     *d = EOS;
  2770.     if (strlen(d) > MAX_TB) {
  2771.         etc_beep();
  2772.         under_print("変換する文字列が長すぎます");
  2773.     } else {
  2774.         strcpy(d0,dd);
  2775.     }
  2776. }
  2777.  
  2778. /* 全角のひらがなを、全角のカタカナにする */
  2779. /* ２バイト半角文字のひらがなもカタカナにする */
  2780. /* １／４角も面倒みる */
  2781. void
  2782. etc_zen_hira_to_kata(STR d,STR s,int size)
  2783. {
  2784.     UINT c;
  2785.  
  2786.     while(s = etc_jfirst_x(s,&c)) {
  2787.         c = etc_zen_hira_to_kata1(c);
  2788.         if (c > 0xff) {    /* ２バイト文字だ */
  2789.             *d++ = (c >> 8);
  2790.             *d++ = c &0xff;
  2791.         } else {
  2792.             *d++ = c;
  2793.         }
  2794.     }
  2795.     *d = EOS;
  2796. }
  2797.  
  2798. UINT
  2799. etc_zen_kata_to_hira1(UINT c)
  2800. {
  2801.     if (jiskata(c)) {
  2802.         if (c <= (UINT) L'ミ') {
  2803.             c -= ((UINT)L'ァ' - (UINT)L'ぁ');
  2804.         } else if ((c >= L'ヴ') && (c <= L'ヶ')) {
  2805.             /* 何もしない */
  2806.         } else {
  2807.             c -= ((UINT)L'ム' - (UINT)L'む');
  2808.         }
  2809.     } else if ((0xa0 <= c) && (c <= 0xdf)) {    /* １バイト半角カタカナだ */
  2810.         if (c != 0xb0) {
  2811.             c = 0x8000 | c;
  2812.         }
  2813.     } else if ((c & 0xff00) == 0xf000) {        /* 上付１／４角 */
  2814.         c = 0xf100 | (c & 0xff);
  2815.     } else if ((c & 0xff00) == 0xf200) {        /* 下付１／４角 */
  2816.         c = 0xf300 | (c & 0xff);
  2817.     }
  2818.     return(c);
  2819. }
  2820.  
  2821.  
  2822. UINT
  2823. etc_zen_hira_to_kata1(UINT c)
  2824. {
  2825.     if (jishira(c)) {    /* ひらがなである */
  2826.         if (c <= (UINT) L'み') {
  2827.             c += ((UINT)L'ァ' - (UINT)L'ぁ');
  2828.         } else {
  2829.             c += ((UINT)L'ム' - (UINT)L'む');
  2830.         }
  2831.     } else if ((0x813f <= c) && (c <0xf000 )) {    /* 普通の２バイト文字 */
  2832.         /* 何もしない */
  2833.     } else if (c > 0xff ) {
  2834.         c = etc_normalize_hira(c);
  2835.         if (c <= 0x80ff) {
  2836.             c &= 0xff;
  2837.         } else {
  2838.             c -= 0x100;
  2839.         }
  2840.     }
  2841.     return(c);
  2842. }
  2843.  
  2844. /* 正規化する */
  2845. UINT
  2846. etc_normalize_hira(UINT c)
  2847. {
  2848.     register int cl;
  2849.  
  2850.     cl = c & 0xff;
  2851.     switch(c & 0xff00) {
  2852.     case 0x8000:
  2853.     case 0xf100:
  2854.     case 0xf300:
  2855.         if ((0x86 <= cl) && (cl < 0xa0)) {
  2856.             c += 0x20;
  2857.         } else if ((0xe0 < cl) && (cl < 0xfe)) {
  2858.             c -= 0x20;
  2859.         }
  2860.         return(c);
  2861.     case 0xf000:
  2862.     case 0xf200:
  2863.         if ((0x86 <= cl) && (cl < 0xa0)) {
  2864.             c += 0x120;
  2865.         } else if ((0xe0 < cl) && (cl < 0xfe)) {
  2866.             c += 0x100 -0x20;
  2867.         }
  2868.         return(c);
  2869.     default:
  2870.         return(c);
  2871.     }
  2872. }
  2873.  
  2874. WORD DIC_MODE;
  2875.  
  2876. void
  2877. etc_exit(int ecode)
  2878. {
  2879.     KNJCTRL(11,DIC_MODE);
  2880.  
  2881.     KNJCTRL(1,0);
  2882.  
  2883.     exit(ecode);
  2884. }
  2885.  
  2886. extern UINT LED_MODE_OUT;
  2887. extern UINT LED_MODE;
  2888.  
  2889. /* 色々する */
  2890. /* click_on | 禁則 | プリンタ情報付加 */
  2891. void
  2892. etc_begin()
  2893. {
  2894.     char *swp,w;
  2895.  
  2896.     LED_MODE_OUT = K_SFTSNS();
  2897.  
  2898.     KNJCTRL(1,1);/* ,,, */
  2899.     LED_MODE = K_SFTSNS();
  2900.     KNJCTRL(1,0);
  2901. #if 0
  2902.     KNJCTRL(7,0);
  2903. #endif
  2904.     KNJCTRL(28);
  2905.     DIC_MODE = KNJCTRL(12);
  2906.  
  2907.     if (swp = (STR)getenv("TWSWITCH")) {
  2908.     } else {
  2909.         swp = (STR)getenv("twswitch");
  2910.     }
  2911.     if (swp) {
  2912.         sysflag = strtol(swp,w,0);/* 各指定が有効 */
  2913.     } else {
  2914.         sysflag = 0;
  2915.     }
  2916.  
  2917.     if (sysflag & 0b10) {
  2918.         cut_switch_change();
  2919.     }
  2920.     if (sysflag & 0b100) {
  2921.         CLICK_MODE = 1;
  2922.     } else {
  2923.         CLICK_MODE = 0;
  2924.     }
  2925. #if 0
  2926.     if (sysflag & 0b1000) {    /* 改行モード */
  2927.     }
  2928. #endif
  2929. /*window0();printf("[%d]",sysflag);binkey();*/
  2930. }
  2931.  
  2932. #if 1
  2933. /* 色々する */
  2934. /* click_on | 禁則 | プリンタ情報付加 */
  2935. void
  2936. etc_begin2()
  2937. {
  2938. #if 1
  2939.     if (!DUM_FLAG) {
  2940.         KNJCTRL(7,0);
  2941.     }
  2942. #endif
  2943.     KNJCTRL(28);
  2944. }
  2945. #endif
  2946.  
  2947. UINT
  2948. etc_is_normal_han(UINT code)
  2949. {
  2950.     return((code < 0x7f) || ((0xa0 <= code) && (code <= 0xdf)));
  2951. }
  2952.  
  2953. /* kc の中に半角か１／４角の２バイト文字が含まれているかどうか返す */
  2954. int
  2955. etc_is_there_han2byte(STR kc)
  2956. {
  2957.     STR p;
  2958.     UINT c;
  2959.  
  2960. /* ２文字目へのポインタを返す */
  2961. /* 最初の文字を返す */
  2962. /* 全角文字にも対応 */
  2963. /* EOS なら NULL を返す */
  2964.     p = kc;
  2965.     while(1) {
  2966.         p = etc_jfirst_x(p,&c);
  2967.         if (c) {
  2968.             if (buff_ishan2byte(c >> 8)) {
  2969.                 return(1);
  2970.             }
  2971.         } else {
  2972.             break;
  2973.         }
  2974.     }
  2975.     return(0);
  2976. }
  2977.